From 3042ef8d5dbb262691a97ff9ef00a39b03360e6b Mon Sep 17 00:00:00 2001 From: Boris Zbarsky Date: Thu, 9 Dec 2021 17:29:55 -0500 Subject: [PATCH] Switch Darwin to the new single-attribute subscription API (#12797) --- .../common/ClusterTestGeneration.js | 8 +- .../CHIP/CHIPCallbackBridgeBase_internal.h | 13 +- .../CHIP/templates/CHIPClustersObjc-src.zapt | 75 +- .../CHIP/templates/CHIPClustersObjc.zapt | 8 +- .../templates/CHIPTestClustersObjc-src.zapt | 2 +- .../partials/CHIPCallbackBridge.zapt | 35 + .../CHIP/templates/partials/test_cluster.zapt | 37 +- .../CHIP/zap-generated/CHIPCallbackBridge.mm | 5711 +++- .../CHIPCallbackBridge_internal.h | 5822 +++- .../CHIP/zap-generated/CHIPClustersObjc.h | 2896 +- .../CHIP/zap-generated/CHIPClustersObjc.mm | 22450 ++++++---------- .../zap-generated/CHIPTestClustersObjc.mm | 910 +- .../Framework/CHIPTests/CHIPClustersTests.m | 34 +- 13 files changed, 22514 insertions(+), 15487 deletions(-) diff --git a/src/app/zap-templates/common/ClusterTestGeneration.js b/src/app/zap-templates/common/ClusterTestGeneration.js index 117c5252600838..25af59fc2e2fe5 100644 --- a/src/app/zap-templates/common/ClusterTestGeneration.js +++ b/src/app/zap-templates/common/ClusterTestGeneration.js @@ -319,7 +319,8 @@ function parse(filename) command : "waitForReport", attribute : test.attribute, response : test.response, - async : true + async : true, + allocateSubscribeDataCallback : true, }; delete test.response; @@ -327,8 +328,9 @@ function parse(filename) yaml.tests.splice(index, 0, reportTest); // Associate the "subscribeAttribute" test with the synthesized report test - test.hasWaitForReport = true; - test.waitForReport = reportTest; + test.hasWaitForReport = true; + test.waitForReport = reportTest; + test.allocateSubscribeDataCallback = !test.hasWaitForReport; } }); diff --git a/src/darwin/Framework/CHIP/CHIPCallbackBridgeBase_internal.h b/src/darwin/Framework/CHIP/CHIPCallbackBridgeBase_internal.h index 6f779627666ec4..35a97dc7bffb17 100644 --- a/src/darwin/Framework/CHIP/CHIPCallbackBridgeBase_internal.h +++ b/src/darwin/Framework/CHIP/CHIPCallbackBridgeBase_internal.h @@ -42,7 +42,7 @@ template class CHIPCallbackBridge { if (CHIP_NO_ERROR != err) { dispatch_async(queue, ^{ - handler([CHIPError errorForCHIPErrorCode:err], nil); + handler(nil, [CHIPError errorForCHIPErrorCode:err]); }); NSString * errorStr = [NSString stringWithFormat:@"%s: %s", typeid(T).name(), chip::ErrorStr(err)]; @@ -58,6 +58,9 @@ template class CHIPCallbackBridge { static void DispatchFailure(void * context, NSError * error) { DispatchCallbackResult(context, error, nil); } +protected: + dispatch_queue_t mQueue; + private: static void DispatchCallbackResult(void * context, NSError * error, id value) { @@ -71,8 +74,13 @@ template class CHIPCallbackBridge { return; } + if (error) { + // We should delete ourselves; there will be no more callbacks. + callbackBridge->mKeepAlive = false; + } + dispatch_async(callbackBridge->mQueue, ^{ - callbackBridge->mHandler(error, value); + callbackBridge->mHandler(value, error); if (!callbackBridge->mKeepAlive) { delete callbackBridge; @@ -80,7 +88,6 @@ template class CHIPCallbackBridge { }); } - dispatch_queue_t mQueue; ResponseHandler mHandler; bool mKeepAlive; diff --git a/src/darwin/Framework/CHIP/templates/CHIPClustersObjc-src.zapt b/src/darwin/Framework/CHIP/templates/CHIPClustersObjc-src.zapt index 4019105463d104..ae6d5ab11895b5 100644 --- a/src/darwin/Framework/CHIP/templates/CHIPClustersObjc-src.zapt +++ b/src/darwin/Framework/CHIP/templates/CHIPClustersObjc-src.zapt @@ -56,15 +56,15 @@ using namespace chip::app::Clusters; {{/chip_cluster_command_arguments}} new CHIP{{>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. }} {{#if hasSpecificResponse}} - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, + {{! This treats completionHandler as taking an id for the data. This is + not great from a type-safety perspective, of course. }} + completionHandler, {{else}} - ^(NSError * _Nullable error, id _Nullable value) { + {{! 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 value, NSError * _Nullable error) { completionHandler(error); }, {{/if}} @@ -82,7 +82,8 @@ using namespace chip::app::Clusters; {{/chip_cluster_commands}} {{#chip_server_cluster_attributes}} -{{! TODO: Need to add support for struct-type attibutes here, and enum-typed ones }} +{{! TODO: Need to add support for struct-type attibutes here. And remove the callbackName + inline duplication with subscribe. }} {{#unless (isStrEqual chipCallback.name "Unsupported")}} {{#*inline "attribute"}}Attribute{{asUpperCamelCase name}}{{/inline}} {{#*inline "callbackName"}} @@ -103,12 +104,9 @@ using namespace chip::app::Clusters; - (void)read{{>attribute}}WithCompletionHandler:(void (^)({{asObjectiveCClass type parent.name}} * _Nullable value, NSError * _Nullable error))completionHandler { new CHIP{{>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. }} - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, + {{! This treats completionHandler as taking an id for the data. This is + not great from a type-safety perspective, of course. }} + completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = {{asUpperCamelCase parent.name}}::Attributes::{{asUpperCamelCase name}}::TypeInfo; auto successFn = Callback<{{>callbackName}}Callback>::FromCancelable(success); @@ -125,7 +123,7 @@ using namespace chip::app::Clusters; {{! 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. }} - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -146,31 +144,36 @@ using namespace chip::app::Clusters; {{/if}} {{#if isReportableAttribute}} -{{#unless isList}} -{{#*inline "callbackName"}}DefaultSuccess{{/inline}} -{{#*inline "callbackParams"}}, minInterval, maxInterval{{#if isAnalog}}, change{{/if}}{{/inline}} -- (void) subscribe{{>attribute}}WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval responseHandler:(ResponseHandler)responseHandler +{{! This callbackName bit is duplicated with the readAttribute code above. }} +{{#*inline "callbackName"}} + {{~#if isList~}} + {{asUpperCamelCase ../name}}{{asUpperCamelCase name}}List + {{~else~}} + {{~#if isNullable}}Nullable{{/if~}} + {{~#if (isStrEqual (asUpperCamelCase type) (asUpperCamelCase "vendor_id"))~}} + VendorId + {{~else if isEnum~}} + {{asUpperCamelCase ../name}}Cluster{{asUpperCamelCase type}} + {{~else~}} + {{chipCallback.name}} + {{~/if~}} + {{~/if~}} + Attribute +{{~/inline}} +- (void) subscribe{{>attribute}}WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler reportHandler:(void (^)({{asObjectiveCClass type parent.name}} * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIP{{>callbackName}}CallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.Subscribe{{>attribute}}(success, failure{{>callbackParams}}); - }); -} - -{{#*inline "callbackName"}}{{#if isNullable}}Nullable{{/if}}{{chipCallback.name}}Attribute{{/inline}} -- (void) report{{>attribute}}WithResponseHandler:(void (^)({{asObjectiveCClass type parent.name}} * _Nullable value, NSError * _Nullable error))responseHandler { - new CHIP{{>callbackName}}CallbackBridge(self.callbackQueue, - {{! For now, don't change the bridge API; instead just use an adapter - to invoke our response handler. This is not great from a - type-safety perspective, of course. }} - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIP{{>callbackName}}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, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.Report{{>attribute}}(success); - }, true); + using TypeInfo = {{asUpperCamelCase parent.name}}::Attributes::{{asUpperCamelCase name}}::TypeInfo; + auto successFn = Callback<{{>callbackName}}Callback>::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, minInterval, maxInterval, CHIP{{>callbackName}}CallbackSubscriptionBridge::OnSubscriptionEstablished); + }, subscriptionEstablishedHandler); } -{{/unless}} {{/if}} {{/unless}} {{/chip_server_cluster_attributes}} diff --git a/src/darwin/Framework/CHIP/templates/CHIPClustersObjc.zapt b/src/darwin/Framework/CHIP/templates/CHIPClustersObjc.zapt index 50daa8f0b6c88a..adf932fd6d772f 100644 --- a/src/darwin/Framework/CHIP/templates/CHIPClustersObjc.zapt +++ b/src/darwin/Framework/CHIP/templates/CHIPClustersObjc.zapt @@ -9,8 +9,9 @@ #include #include -typedef void (^ResponseHandler)(NSError * _Nullable error, id _Nullable values); +typedef void (^ResponseHandler)(id _Nullable value, NSError * _Nullable error); typedef void (^StatusCompletion)(NSError * _Nullable error); +typedef void (^SubscriptionEstablishedHandler)(void); NS_ASSUME_NONNULL_BEGIN @@ -44,10 +45,7 @@ NS_ASSUME_NONNULL_BEGIN - (void)write{{>attribute}}WithValue:({{asObjectiveCType type parent.name}})value completionHandler:(StatusCompletion)completionHandler; {{/if}} {{#if isReportableAttribute}} -{{#unless isList}} -- (void) subscribe{{>attribute}}WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval responseHandler:(ResponseHandler)responseHandler; -- (void) report{{>attribute}}WithResponseHandler:(void (^)({{asObjectiveCClass type parent.name}} * _Nullable value, NSError * _Nullable error))responseHandler; -{{/unless}} +- (void) subscribe{{>attribute}}WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler reportHandler:(void (^)({{asObjectiveCClass type parent.name}} * _Nullable value, NSError * _Nullable error))reportHandler; {{/if}} {{/unless}} {{/chip_server_cluster_attributes}} diff --git a/src/darwin/Framework/CHIP/templates/CHIPTestClustersObjc-src.zapt b/src/darwin/Framework/CHIP/templates/CHIPTestClustersObjc-src.zapt index 0cf1787a5a08f0..bb2937682d98ff 100644 --- a/src/darwin/Framework/CHIP/templates/CHIPTestClustersObjc-src.zapt +++ b/src/darwin/Framework/CHIP/templates/CHIPTestClustersObjc-src.zapt @@ -40,7 +40,7 @@ using namespace chip::app::Clusters; {{! 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. }} - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { diff --git a/src/darwin/Framework/CHIP/templates/partials/CHIPCallbackBridge.zapt b/src/darwin/Framework/CHIP/templates/partials/CHIPCallbackBridge.zapt index 510ed374c58909..097ecd49d0479b 100644 --- a/src/darwin/Framework/CHIP/templates/partials/CHIPCallbackBridge.zapt +++ b/src/darwin/Framework/CHIP/templates/partials/CHIPCallbackBridge.zapt @@ -33,6 +33,23 @@ public: {{/if}} ); }; + +{{#unless partial-type}} +class CHIP{{> @partial-block}}SubscriptionBridge : public CHIP{{> @partial-block}}Bridge +{ +public: + CHIP{{> @partial-block}}SubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, SubscriptionEstablishedHandler establishedHandler) + : CHIP{{> @partial-block}}Bridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; +{{/unless}} + {{else}} void CHIP{{> @partial-block}}Bridge::OnSuccessFn(void * context {{#if partial-type}} @@ -74,4 +91,22 @@ void CHIP{{> @partial-block}}Bridge::OnSuccessFn(void * context DispatchSuccess(context, objCValue); {{/if}} }; + +{{#unless partial-type}} +void CHIP{{> @partial-block}}SubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast @partial-block}}SubscriptionBridge *>(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} +{{/unless}} {{/if}} diff --git a/src/darwin/Framework/CHIP/templates/partials/test_cluster.zapt b/src/darwin/Framework/CHIP/templates/partials/test_cluster.zapt index 3ba5976acaf0d9..edd4515f47cb81 100644 --- a/src/darwin/Framework/CHIP/templates/partials/test_cluster.zapt +++ b/src/darwin/Framework/CHIP/templates/partials/test_cluster.zapt @@ -8,6 +8,14 @@ bool testSendCluster{{parent.filename}}_{{asTestIndex index}}_{{asUpperCamelCase {{asBasicType chipType}} {{saveAs}}; {{/if}} {{/chip_tests_item_response_parameters}} + +{{~#*inline "subscribeDataCallback"}} +test_{{parent.filename}}_{{attribute}}_Reported +{{/inline}} +{{#if allocateSubscribeDataCallback}} +ResponseHandler {{> subscribeDataCallback}} = nil; +{{/if~}} + - (void)testSendCluster{{parent.filename}}_{{asTestIndex index}}_{{asUpperCamelCase command}} { {{#unless async}} @@ -43,21 +51,17 @@ bool testSendCluster{{parent.filename}}_{{asTestIndex index}}_{{asUpperCamelCase {{/if}} {{else if isSubscribeAttribute}} {{#chip_tests_item_parameters}} - {{#if (isString type)}} - {{#if (isOctetString type)}} - NSData * {{asLowerCamelCase name}}Argument = [[NSData alloc] initWithBytes:"{{octetStringEscapedForCLiteral definedValue}}" length:{{definedValue.length}}]; - {{else}} - NSString * {{asLowerCamelCase name}}Argument= @"{{definedValue}}"; - {{/if}} - {{else}} {{asObjectiveCBasicType type}} {{asLowerCamelCase name}}Argument = {{asTypedLiteral definedValue type}}; - {{/if}} {{/chip_tests_item_parameters}} [cluster subscribeAttribute{{asUpperCamelCase attribute}}WithMinInterval:minIntervalArgument maxInterval:maxIntervalArgument - responseHandler:^(NSError * err, NSDictionary * values) { + subscriptionEstablished:^{ + XCTAssertEqual(testSendCluster{{parent.filename}}_{{asTestIndex waitForReport.index}}_{{asUpperCamelCase waitForReport.command}}_Fulfilled, true); + [expectation fulfill]; + } + reportHandler:^({{asObjectiveCClass attributeObject.type cluster forceList=attributeObject.isList}} * _Nullable value, NSError * _Nullable err) { {{else if isWaitForReport}} - [cluster reportAttribute{{asUpperCamelCase attribute}}WithResponseHandler:^({{asObjectiveCClass attributeObject.type cluster forceList=attributeObject.isList}} * _Nullable value, NSError * _Nullable err) { + {{> subscribeDataCallback }} = ^({{asObjectiveCClass attributeObject.type cluster forceList=attributeObject.isList}} * _Nullable value, NSError * _Nullable err) { {{else if isReadAttribute}} [cluster readAttribute{{asUpperCamelCase attribute}}WithCompletionHandler:^({{asObjectiveCClass attributeObject.type cluster forceList=attributeObject.isList}} * _Nullable value, NSError * _Nullable err) { {{else if isWriteAttribute}} @@ -149,16 +153,21 @@ bool testSendCluster{{parent.filename}}_{{asTestIndex index}}_{{asUpperCamelCase {{/if}} {{/chip_tests_item_response_parameters}} - {{else}} - XCTAssertEqual(testSendCluster{{parent.filename}}_{{asTestIndex waitForReport.index}}_{{asUpperCamelCase waitForReport.command}}_Fulfilled, true); - {{/unless}} {{#unless async}} [expectation fulfill]; {{else}} testSendCluster{{parent.filename}}_{{asTestIndex index}}_{{asUpperCamelCase command}}_Fulfilled = true; {{/unless}} + {{else}} + {{! We're a subscription }} + if ({{> subscribeDataCallback}} != nil) { + ResponseHandler callback = {{> subscribeDataCallback}}; + {{> subscribeDataCallback}} = nil; + callback(value, err); + } + {{/unless}} {{/if}} - }]; + }{{#unless isWaitForReport}}]{{/unless}}; {{/if}} {{#unless async}} diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge.mm b/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge.mm index 6d6715ff9fd450..1565bc23a6060a 100644 --- a/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge.mm +++ b/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge.mm @@ -37,6 +37,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPOctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableOctetStringAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -49,6 +65,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableOctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPCharStringAttributeCallbackBridge::OnSuccessFn(void * context, chip::CharSpan value) { NSString * _Nonnull objCValue; @@ -56,6 +88,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableCharStringAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -68,6 +116,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPBooleanAttributeCallbackBridge::OnSuccessFn(void * context, bool value) { NSNumber * _Nonnull objCValue; @@ -75,6 +139,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableBooleanAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::Nullable & value) { NSNumber * _Nullable objCValue; @@ -86,6 +166,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPInt8uAttributeCallbackBridge::OnSuccessFn(void * context, uint8_t value) { NSNumber * _Nonnull objCValue; @@ -93,6 +189,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableInt8uAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::Nullable & value) { NSNumber * _Nullable objCValue; @@ -104,6 +216,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPInt8sAttributeCallbackBridge::OnSuccessFn(void * context, int8_t value) { NSNumber * _Nonnull objCValue; @@ -111,6 +239,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableInt8sAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::Nullable & value) { NSNumber * _Nullable objCValue; @@ -122,6 +266,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPInt16uAttributeCallbackBridge::OnSuccessFn(void * context, uint16_t value) { NSNumber * _Nonnull objCValue; @@ -129,6 +289,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableInt16uAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::Nullable & value) { NSNumber * _Nullable objCValue; @@ -140,6 +316,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPInt16sAttributeCallbackBridge::OnSuccessFn(void * context, int16_t value) { NSNumber * _Nonnull objCValue; @@ -147,6 +339,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableInt16sAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::Nullable & value) { NSNumber * _Nullable objCValue; @@ -158,6 +366,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPInt32uAttributeCallbackBridge::OnSuccessFn(void * context, uint32_t value) { NSNumber * _Nonnull objCValue; @@ -165,6 +389,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableInt32uAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::Nullable & value) { NSNumber * _Nullable objCValue; @@ -176,6 +416,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPInt32sAttributeCallbackBridge::OnSuccessFn(void * context, int32_t value) { NSNumber * _Nonnull objCValue; @@ -183,6 +439,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableInt32sAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::Nullable & value) { NSNumber * _Nullable objCValue; @@ -194,6 +466,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPInt64uAttributeCallbackBridge::OnSuccessFn(void * context, uint64_t value) { NSNumber * _Nonnull objCValue; @@ -201,6 +489,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableInt64uAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::Nullable & value) { NSNumber * _Nullable objCValue; @@ -212,6 +516,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPInt64sAttributeCallbackBridge::OnSuccessFn(void * context, int64_t value) { NSNumber * _Nonnull objCValue; @@ -219,6 +539,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableInt64sAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::Nullable & value) { NSNumber * _Nullable objCValue; @@ -230,6 +566,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPFloatAttributeCallbackBridge::OnSuccessFn(void * context, float value) { NSNumber * _Nonnull objCValue; @@ -237,6 +589,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPFloatAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableFloatAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::Nullable & value) { NSNumber * _Nullable objCValue; @@ -248,6 +616,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableFloatAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPDoubleAttributeCallbackBridge::OnSuccessFn(void * context, double value) { NSNumber * _Nonnull objCValue; @@ -255,6 +639,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPDoubleAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableDoubleAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::Nullable & value) { NSNumber * _Nullable objCValue; @@ -266,6 +666,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableDoubleAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPVendorIdAttributeCallbackBridge::OnSuccessFn(void * context, chip::VendorId value) { NSNumber * _Nonnull objCValue; @@ -273,6 +689,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPVendorIdAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableVendorIdAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -285,6 +717,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableVendorIdAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPAccessControlAclListAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value) @@ -354,6 +802,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPAccessControlAclListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPAccessControlExtensionListAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value) { @@ -376,6 +840,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPAccessControlExtensionListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPAccessControlAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -396,6 +876,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPAccessControlAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPAccountLoginAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -416,6 +912,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPAccountLoginAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPAdministratorCommissioningAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -436,6 +948,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPAdministratorCommissioningAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPApplicationBasicAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -456,6 +984,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPApplicationBasicAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPApplicationLauncherApplicationLauncherListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -476,6 +1020,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPApplicationLauncherApplicationLauncherListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPApplicationLauncherAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -496,6 +1057,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPApplicationLauncherAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPAudioOutputAudioOutputListListAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value) { @@ -521,6 +1098,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPAudioOutputAudioOutputListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPAudioOutputAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -541,6 +1134,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPAudioOutputAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPBarrierControlAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -561,6 +1170,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPBarrierControlAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPBasicAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -581,6 +1206,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPBasicAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPBinaryInputBasicAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -601,6 +1242,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPBinaryInputBasicAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPBindingAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -621,6 +1278,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPBindingAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPBooleanStateAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -641,11 +1314,27 @@ DispatchSuccess(context, objCValue); }; -void CHIPBridgedActionsActionListListAttributeCallbackBridge::OnSuccessFn(void * context, - const chip::app::DataModel::DecodableList & value) +void CHIPBooleanStateAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) { - NSArray * _Nonnull objCValue; - auto * array_0 = [NSMutableArray new]; + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + +void CHIPBridgedActionsActionListListAttributeCallbackBridge::OnSuccessFn(void * context, + const chip::app::DataModel::DecodableList & value) +{ + NSArray * _Nonnull objCValue; + auto * array_0 = [NSMutableArray new]; auto iter_0 = value.begin(); while (iter_0.Next()) { auto & entry_0 = iter_0.GetValue(); @@ -669,6 +1358,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPBridgedActionsActionListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPBridgedActionsEndpointListListAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value) @@ -706,6 +1411,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPBridgedActionsEndpointListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPBridgedActionsAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -726,6 +1447,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPBridgedActionsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPBridgedDeviceBasicAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -746,6 +1483,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPBridgedDeviceBasicAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPColorControlAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -766,6 +1519,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPColorControlAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPContentLauncherAcceptsHeaderListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -786,6 +1555,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPContentLauncherAcceptsHeaderListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPContentLauncherSupportedStreamingTypesListAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value) { @@ -806,6 +1591,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPContentLauncherSupportedStreamingTypesListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPContentLauncherAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -826,6 +1627,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPContentLauncherAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPDescriptorDeviceListListAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value) { @@ -848,6 +1665,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPDescriptorDeviceListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPDescriptorServerListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -868,6 +1701,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPDescriptorServerListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPDescriptorClientListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -888,6 +1737,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPDescriptorClientListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPDescriptorPartsListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -908,6 +1773,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPDescriptorPartsListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPDescriptorAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -928,6 +1809,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPDescriptorAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPDiagnosticLogsAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -948,6 +1845,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPDiagnosticLogsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPDoorLockAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -968,6 +1881,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPDoorLockAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPElectricalMeasurementAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -988,6 +1917,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPElectricalMeasurementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPEthernetNetworkDiagnosticsAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1008,6 +1953,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPEthernetNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPFixedLabelLabelListListAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value) { @@ -1040,6 +2001,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPFixedLabelLabelListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPFixedLabelAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1060,6 +2037,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPFixedLabelAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPFlowMeasurementAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1080,6 +2073,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPFlowMeasurementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPGeneralCommissioningBasicCommissioningInfoListListAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::DecodableList< chip::app::Clusters::GeneralCommissioning::Structs::BasicCommissioningInfoType::DecodableType> & value) @@ -1102,6 +2111,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPGeneralCommissioningBasicCommissioningInfoListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPGeneralCommissioningAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1122,6 +2148,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPGeneralCommissioningAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPGeneralDiagnosticsNetworkInterfacesListAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::DecodableList< chip::app::Clusters::GeneralDiagnostics::Structs::NetworkInterfaceType::DecodableType> & value) @@ -1151,6 +2193,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPGeneralDiagnosticsNetworkInterfacesListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1171,6 +2229,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1191,6 +2265,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1211,6 +2301,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPGeneralDiagnosticsAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1231,6 +2337,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPGeneralDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPGroupKeyManagementGroupsListAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value) { @@ -1254,6 +2376,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPGroupKeyManagementGroupsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPGroupKeyManagementGroupKeysListAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value) { @@ -1279,6 +2417,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPGroupKeyManagementGroupKeysListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPGroupKeyManagementAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1299,6 +2453,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPGroupKeyManagementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPGroupsAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1319,6 +2489,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPGroupsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPIdentifyAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1339,6 +2525,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPIdentifyAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPIlluminanceMeasurementAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1359,6 +2561,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPIlluminanceMeasurementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPKeypadInputAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1379,6 +2597,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPKeypadInputAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPLevelControlAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1399,6 +2633,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPLevelControlAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPLowPowerAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1419,6 +2669,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPLowPowerAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPMediaInputMediaInputListListAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value) { @@ -1447,6 +2713,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPMediaInputMediaInputListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPMediaInputAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1467,6 +2749,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPMediaInputAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPMediaPlaybackAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1487,6 +2785,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPMediaPlaybackAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPModeSelectSupportedModesListAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value) { @@ -1512,6 +2826,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPModeSelectSupportedModesListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPModeSelectAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1532,6 +2862,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPModeSelectAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNetworkCommissioningAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1552,6 +2898,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNetworkCommissioningAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPOtaSoftwareUpdateProviderAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1572,6 +2934,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPOtaSoftwareUpdateProviderAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPOtaSoftwareUpdateRequestorAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1592,6 +2970,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPOtaSoftwareUpdateRequestorAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPOccupancySensingAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1612,6 +3006,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPOccupancySensingAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPOnOffAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1632,6 +3042,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPOnOffAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPOnOffSwitchConfigurationAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1652,6 +3078,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPOnOffSwitchConfigurationAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPOperationalCredentialsFabricsListListAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::DecodableList< chip::app::Clusters::OperationalCredentials::Structs::FabricDescriptor::DecodableType> & value) @@ -1681,6 +3123,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPOperationalCredentialsFabricsListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPOperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1701,6 +3159,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPOperationalCredentialsTrustedRootCertificatesListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPOperationalCredentialsAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1721,6 +3196,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPOperationalCredentialsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPPowerSourceActiveBatteryFaultsListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1741,6 +3232,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPPowerSourceActiveBatteryFaultsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPPowerSourceAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1761,6 +3268,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPPowerSourceAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPPowerSourceConfigurationSourcesListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1781,6 +3304,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPPowerSourceConfigurationSourcesListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPPowerSourceConfigurationAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1801,6 +3340,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPPowerSourceConfigurationAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPPressureMeasurementAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1821,6 +3376,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPPressureMeasurementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPPumpConfigurationAndControlAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1841,6 +3412,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPPumpConfigurationAndControlAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPRelativeHumidityMeasurementAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1861,6 +3448,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPRelativeHumidityMeasurementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPScenesAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1881,6 +3484,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPScenesAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPSoftwareDiagnosticsThreadMetricsListAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value) @@ -1909,6 +3528,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPSoftwareDiagnosticsThreadMetricsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPSoftwareDiagnosticsAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1929,6 +3564,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPSoftwareDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPSwitchAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -1949,6 +3600,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPSwitchAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPTvChannelTvChannelListListAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value) { @@ -1980,6 +3647,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPTvChannelTvChannelListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPTvChannelAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -2000,6 +3683,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPTvChannelAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPTargetNavigatorTargetNavigatorListListAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::DecodableList< chip::app::Clusters::TargetNavigator::Structs::NavigateTargetTargetInfo::DecodableType> & value) @@ -2025,6 +3724,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPTargetNavigatorTargetNavigatorListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPTargetNavigatorAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -2045,6 +3760,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPTargetNavigatorAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPTemperatureMeasurementAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -2065,6 +3796,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPTemperatureMeasurementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPTestClusterListInt8uListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -2085,6 +3832,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPTestClusterListInt8uListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPTestClusterListOctetStringListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -2105,6 +3868,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPTestClusterListOctetStringListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPTestClusterListStructOctetStringListAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value) @@ -2128,6 +3907,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPTestClusterListStructOctetStringListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::DecodableList< chip::app::Clusters::TestCluster::Structs::NullablesAndOptionalsStruct::DecodableType> & value) @@ -2301,6 +4096,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPTestClusterListNullablesAndOptionalsStructListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPTestClusterListLongOctetStringListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -2321,6 +4133,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPTestClusterListLongOctetStringListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPTestClusterAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -2341,6 +4169,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPTestClusterAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPThermostatAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -2361,6 +4205,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPThermostatAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -2381,6 +4241,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::DecodableList< chip::app::Clusters::ThreadNetworkDiagnostics::Structs::NeighborTable::DecodableType> & value) @@ -2416,6 +4294,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPThreadNetworkDiagnosticsRouteTableListListAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value) @@ -2447,6 +4341,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPThreadNetworkDiagnosticsRouteTableListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPThreadNetworkDiagnosticsSecurityPolicyListAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::DecodableList< chip::app::Clusters::ThreadNetworkDiagnostics::Structs::SecurityPolicy::DecodableType> & value) @@ -2470,6 +4380,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPThreadNetworkDiagnosticsSecurityPolicyListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPThreadNetworkDiagnosticsOperationalDatasetComponentsListAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::DecodableList< chip::app::Clusters::ThreadNetworkDiagnostics::Structs::OperationalDatasetComponents::DecodableType> & value) @@ -2503,6 +4429,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPThreadNetworkDiagnosticsOperationalDatasetComponentsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -2523,6 +4467,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPThreadNetworkDiagnosticsAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -2543,6 +4505,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPThreadNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPWakeOnLanAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -2563,6 +4541,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPWakeOnLanAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPWiFiNetworkDiagnosticsAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -2583,6 +4577,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPWiFiNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPWindowCoveringAttributeListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { @@ -2603,6 +4613,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPWindowCoveringAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPAccountLoginClusterGetSetupPINResponseCallbackBridge::OnSuccessFn( void * context, const chip::app::Clusters::AccountLogin::Commands::GetSetupPINResponse::DecodableType & data) { @@ -3958,11 +5984,27 @@ DispatchSuccess(context, objCValue); }; -void CHIPNullableIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge::OnSuccessFn( - void * context, const chip::app::DataModel::Nullable & value) +void CHIPIdentifyClusterIdentifyEffectIdentifierAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) { - NSNumber * _Nullable objCValue; - if (value.IsNull()) { + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + +void CHIPNullableIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge::OnSuccessFn( + void * context, const chip::app::DataModel::Nullable & value) +{ + NSNumber * _Nullable objCValue; + if (value.IsNull()) { objCValue = nil; } else { objCValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(value.Value())]; @@ -3970,6 +6012,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableIdentifyClusterIdentifyEffectIdentifierAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::Identify::IdentifyEffectVariant value) { @@ -3978,6 +6037,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPIdentifyClusterIdentifyEffectVariantAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -3990,6 +6065,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableIdentifyClusterIdentifyEffectVariantAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::Identify::IdentifyIdentifyType value) { @@ -3998,6 +6089,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPIdentifyClusterIdentifyIdentifyTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4010,6 +6117,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableIdentifyClusterIdentifyIdentifyTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::OnOff::OnOffDelayedAllOffEffectVariant value) { @@ -4018,6 +6141,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4030,6 +6169,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::OnOff::OnOffDyingLightEffectVariant value) { @@ -4038,6 +6195,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4050,6 +6223,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPOnOffClusterOnOffEffectIdentifierAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::OnOff::OnOffEffectIdentifier value) { @@ -4058,6 +6248,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPOnOffClusterOnOffEffectIdentifierAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableOnOffClusterOnOffEffectIdentifierAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4070,6 +6276,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableOnOffClusterOnOffEffectIdentifierAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPLevelControlClusterMoveModeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::LevelControl::MoveMode value) { @@ -4078,6 +6300,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPLevelControlClusterMoveModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableLevelControlClusterMoveModeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4090,6 +6328,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableLevelControlClusterMoveModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPLevelControlClusterStepModeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::LevelControl::StepMode value) { @@ -4098,6 +6352,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPLevelControlClusterStepModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableLevelControlClusterStepModeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4110,6 +6380,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableLevelControlClusterStepModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPApplianceControlClusterApplianceStatusAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::ApplianceControl::ApplianceStatus value) { @@ -4118,6 +6404,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPApplianceControlClusterApplianceStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableApplianceControlClusterApplianceStatusAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4130,6 +6432,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableApplianceControlClusterApplianceStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPApplianceControlClusterCommandIdentificationAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::ApplianceControl::CommandIdentification value) { @@ -4138,6 +6457,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPApplianceControlClusterCommandIdentificationAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableApplianceControlClusterCommandIdentificationAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4150,6 +6485,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableApplianceControlClusterCommandIdentificationAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPApplianceControlClusterWarningEventAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::ApplianceControl::WarningEvent value) { @@ -4158,6 +6511,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPApplianceControlClusterWarningEventAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableApplianceControlClusterWarningEventAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4170,6 +6539,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableApplianceControlClusterWarningEventAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPAccessControlClusterAuthModeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::AccessControl::AuthMode value) { @@ -4178,6 +6563,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPAccessControlClusterAuthModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableAccessControlClusterAuthModeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4190,6 +6591,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableAccessControlClusterAuthModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPAccessControlClusterPrivilegeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::AccessControl::Privilege value) { @@ -4198,6 +6615,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPAccessControlClusterPrivilegeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableAccessControlClusterPrivilegeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4210,6 +6643,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableAccessControlClusterPrivilegeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPBridgedActionsClusterActionErrorEnumAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::BridgedActions::ActionErrorEnum value) { @@ -4218,6 +6667,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPBridgedActionsClusterActionErrorEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableBridgedActionsClusterActionErrorEnumAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4230,6 +6695,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableBridgedActionsClusterActionErrorEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPBridgedActionsClusterActionStateEnumAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::BridgedActions::ActionStateEnum value) { @@ -4238,6 +6719,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPBridgedActionsClusterActionStateEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableBridgedActionsClusterActionStateEnumAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4250,6 +6747,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableBridgedActionsClusterActionStateEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPBridgedActionsClusterActionTypeEnumAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::BridgedActions::ActionTypeEnum value) { @@ -4258,6 +6771,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPBridgedActionsClusterActionTypeEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableBridgedActionsClusterActionTypeEnumAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4270,6 +6799,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableBridgedActionsClusterActionTypeEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPBridgedActionsClusterEndpointListTypeEnumAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::BridgedActions::EndpointListTypeEnum value) { @@ -4278,6 +6823,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPBridgedActionsClusterEndpointListTypeEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableBridgedActionsClusterEndpointListTypeEnumAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4290,6 +6851,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableBridgedActionsClusterEndpointListTypeEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPOtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::OtaSoftwareUpdateProvider::OTAApplyUpdateAction value) { @@ -4298,6 +6876,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPOtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableOtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::Nullable & value) { @@ -4310,6 +6906,25 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableOtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast( + context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPOtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::OtaSoftwareUpdateProvider::OTADownloadProtocol value) { @@ -4318,6 +6933,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPOtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableOtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::Nullable & value) { @@ -4330,6 +6963,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableOtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast( + context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPOtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::OtaSoftwareUpdateProvider::OTAQueryStatus value) { @@ -4338,6 +6989,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPOtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableOtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4350,6 +7018,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableOtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPOtaSoftwareUpdateRequestorClusterChangeReasonEnumAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::OtaSoftwareUpdateRequestor::ChangeReasonEnum value) { @@ -4358,6 +7044,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPOtaSoftwareUpdateRequestorClusterChangeReasonEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableOtaSoftwareUpdateRequestorClusterChangeReasonEnumAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4370,6 +7073,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableOtaSoftwareUpdateRequestorClusterChangeReasonEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPOtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::OtaSoftwareUpdateRequestor::OTAAnnouncementReason value) { @@ -4378,6 +7099,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPOtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableOtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::Nullable & value) { @@ -4390,6 +7129,25 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableOtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackSubscriptionBridge:: + OnSubscriptionEstablished(void * context) +{ + auto * self + = static_cast( + context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPOtaSoftwareUpdateRequestorClusterUpdateStateEnumAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::OtaSoftwareUpdateRequestor::UpdateStateEnum value) { @@ -4398,6 +7156,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPOtaSoftwareUpdateRequestorClusterUpdateStateEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableOtaSoftwareUpdateRequestorClusterUpdateStateEnumAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4410,6 +7185,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableOtaSoftwareUpdateRequestorClusterUpdateStateEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPGeneralCommissioningClusterGeneralCommissioningErrorAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::GeneralCommissioning::GeneralCommissioningError value) { @@ -4418,6 +7211,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPGeneralCommissioningClusterGeneralCommissioningErrorAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableGeneralCommissioningClusterGeneralCommissioningErrorAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::Nullable & value) { @@ -4430,6 +7241,25 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableGeneralCommissioningClusterGeneralCommissioningErrorAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast( + context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::GeneralCommissioning::RegulatoryLocationType value) { @@ -4438,6 +7268,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4450,6 +7297,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNetworkCommissioningClusterNetworkCommissioningErrorAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::NetworkCommissioning::NetworkCommissioningError value) { @@ -4458,6 +7323,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPNetworkCommissioningClusterNetworkCommissioningErrorAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableNetworkCommissioningClusterNetworkCommissioningErrorAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::Nullable & value) { @@ -4467,8 +7350,27 @@ } else { objCValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(value.Value())]; } - DispatchSuccess(context, objCValue); -}; + DispatchSuccess(context, objCValue); +}; + +void CHIPNullableNetworkCommissioningClusterNetworkCommissioningErrorAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast( + context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} void CHIPDiagnosticLogsClusterLogsIntentAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::DiagnosticLogs::LogsIntent value) @@ -4478,6 +7380,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPDiagnosticLogsClusterLogsIntentAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableDiagnosticLogsClusterLogsIntentAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4490,6 +7408,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableDiagnosticLogsClusterLogsIntentAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPDiagnosticLogsClusterLogsStatusAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::DiagnosticLogs::LogsStatus value) { @@ -4498,6 +7432,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPDiagnosticLogsClusterLogsStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableDiagnosticLogsClusterLogsStatusAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4510,6 +7460,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableDiagnosticLogsClusterLogsStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::DiagnosticLogs::LogsTransferProtocol value) { @@ -4518,6 +7484,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4530,6 +7512,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::GeneralDiagnostics::BootReasonType value) { @@ -4538,6 +7537,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4550,6 +7565,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::GeneralDiagnostics::HardwareFaultType value) { @@ -4558,6 +7590,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4570,6 +7618,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::GeneralDiagnostics::InterfaceType value) { @@ -4578,6 +7643,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4590,6 +7671,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::GeneralDiagnostics::NetworkFaultType value) { @@ -4598,6 +7696,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4610,6 +7724,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::GeneralDiagnostics::RadioFaultType value) { @@ -4618,6 +7749,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4630,6 +7777,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::ThreadNetworkDiagnostics::NetworkFault value) { @@ -4638,6 +7802,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4650,6 +7830,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::ThreadNetworkDiagnostics::RoutingRole value) { @@ -4658,6 +7856,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4670,6 +7884,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::ThreadNetworkDiagnostics::ThreadConnectionStatus value) { @@ -4678,6 +7909,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::Nullable & value) { @@ -4690,6 +7939,25 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackSubscriptionBridge:: + OnSubscriptionEstablished(void * context) +{ + auto * self + = static_cast( + context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::WiFiNetworkDiagnostics::AssociationFailureCause value) { @@ -4698,6 +7966,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::Nullable & value) { @@ -4710,6 +7996,25 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast( + context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::WiFiNetworkDiagnostics::SecurityType value) { @@ -4718,6 +8023,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4730,6 +8051,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::WiFiNetworkDiagnostics::WiFiConnectionStatus value) { @@ -4738,6 +8076,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4750,6 +8105,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::WiFiNetworkDiagnostics::WiFiVersionType value) { @@ -4758,6 +8131,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4770,6 +8159,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::EthernetNetworkDiagnostics::PHYRateType value) { @@ -4778,6 +8185,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4790,6 +8213,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::AdministratorCommissioning::CommissioningWindowStatus value) { @@ -4798,6 +8239,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::Nullable & value) { @@ -4810,6 +8269,25 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackSubscriptionBridge:: + OnSubscriptionEstablished(void * context) +{ + auto * self + = static_cast( + context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::AdministratorCommissioning::StatusCode value) { @@ -4818,6 +8296,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPAdministratorCommissioningClusterStatusCodeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4830,6 +8324,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableAdministratorCommissioningClusterStatusCodeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPOperationalCredentialsClusterNodeOperationalCertStatusAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::OperationalCredentials::NodeOperationalCertStatus value) { @@ -4838,6 +8350,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPOperationalCredentialsClusterNodeOperationalCertStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableOperationalCredentialsClusterNodeOperationalCertStatusAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::Nullable & value) { @@ -4850,6 +8380,25 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableOperationalCredentialsClusterNodeOperationalCertStatusAttributeCallbackSubscriptionBridge:: + OnSubscriptionEstablished(void * context) +{ + auto * self + = static_cast( + context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::GroupKeyManagement::GroupKeySecurityPolicy value) { @@ -4858,6 +8407,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4870,6 +8436,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPDoorLockClusterDlAlarmCodeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::DoorLock::DlAlarmCode value) { @@ -4878,6 +8462,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPDoorLockClusterDlAlarmCodeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableDoorLockClusterDlAlarmCodeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4887,8 +8487,24 @@ } else { objCValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(value.Value())]; } - DispatchSuccess(context, objCValue); -}; + DispatchSuccess(context, objCValue); +}; + +void CHIPNullableDoorLockClusterDlAlarmCodeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} void CHIPDoorLockClusterDlCredentialRuleAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::DoorLock::DlCredentialRule value) @@ -4898,6 +8514,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPDoorLockClusterDlCredentialRuleAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableDoorLockClusterDlCredentialRuleAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4910,6 +8542,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableDoorLockClusterDlCredentialRuleAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPDoorLockClusterDlCredentialTypeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::DoorLock::DlCredentialType value) { @@ -4918,6 +8566,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPDoorLockClusterDlCredentialTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableDoorLockClusterDlCredentialTypeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4930,6 +8594,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableDoorLockClusterDlCredentialTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPDoorLockClusterDlDataOperationTypeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::DoorLock::DlDataOperationType value) { @@ -4938,6 +8618,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPDoorLockClusterDlDataOperationTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableDoorLockClusterDlDataOperationTypeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4950,6 +8646,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableDoorLockClusterDlDataOperationTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPDoorLockClusterDlDoorLockStatusAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::DoorLock::DlDoorLockStatus value) { @@ -4958,6 +8670,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPDoorLockClusterDlDoorLockStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableDoorLockClusterDlDoorLockStatusAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4970,6 +8698,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableDoorLockClusterDlDoorLockStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPDoorLockClusterDlDoorStateAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::DoorLock::DlDoorState value) { @@ -4978,6 +8722,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPDoorLockClusterDlDoorStateAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableDoorLockClusterDlDoorStateAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -4990,6 +8750,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableDoorLockClusterDlDoorStateAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPDoorLockClusterDlLockDataTypeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::DoorLock::DlLockDataType value) { @@ -4998,6 +8774,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPDoorLockClusterDlLockDataTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableDoorLockClusterDlLockDataTypeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5010,6 +8802,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableDoorLockClusterDlLockDataTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPDoorLockClusterDlLockOperationTypeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::DoorLock::DlLockOperationType value) { @@ -5018,6 +8826,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPDoorLockClusterDlLockOperationTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableDoorLockClusterDlLockOperationTypeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5030,6 +8854,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableDoorLockClusterDlLockOperationTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPDoorLockClusterDlLockStateAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::DoorLock::DlLockState value) { @@ -5038,6 +8878,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableDoorLockClusterDlLockStateAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5050,6 +8906,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPDoorLockClusterDlLockTypeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::DoorLock::DlLockType value) { @@ -5058,6 +8930,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableDoorLockClusterDlLockTypeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5070,6 +8958,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPDoorLockClusterDlOperatingModeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::DoorLock::DlOperatingMode value) { @@ -5078,6 +8982,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPDoorLockClusterDlOperatingModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableDoorLockClusterDlOperatingModeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5090,6 +9010,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableDoorLockClusterDlOperatingModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPDoorLockClusterDlOperationErrorAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::DoorLock::DlOperationError value) { @@ -5098,6 +9034,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPDoorLockClusterDlOperationErrorAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableDoorLockClusterDlOperationErrorAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5110,6 +9062,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableDoorLockClusterDlOperationErrorAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPDoorLockClusterDlOperationSourceAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::DoorLock::DlOperationSource value) { @@ -5118,6 +9086,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPDoorLockClusterDlOperationSourceAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableDoorLockClusterDlOperationSourceAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5130,6 +9114,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableDoorLockClusterDlOperationSourceAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPDoorLockClusterDlStatusAttributeCallbackBridge::OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlStatus value) { NSNumber * _Nonnull objCValue; @@ -5137,6 +9137,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPDoorLockClusterDlStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableDoorLockClusterDlStatusAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5149,6 +9165,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableDoorLockClusterDlStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPDoorLockClusterDlUserStatusAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::DoorLock::DlUserStatus value) { @@ -5157,6 +9189,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPDoorLockClusterDlUserStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableDoorLockClusterDlUserStatusAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5169,6 +9217,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableDoorLockClusterDlUserStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPDoorLockClusterDlUserTypeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::DoorLock::DlUserType value) { @@ -5177,6 +9241,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPDoorLockClusterDlUserTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableDoorLockClusterDlUserTypeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5189,6 +9269,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableDoorLockClusterDlUserTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::DoorLock::DoorLockOperationEventCode value) { @@ -5197,6 +9293,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPDoorLockClusterDoorLockOperationEventCodeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5209,6 +9321,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableDoorLockClusterDoorLockOperationEventCodeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::DoorLock::DoorLockProgrammingEventCode value) { @@ -5217,6 +9346,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5229,6 +9374,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::DoorLock::DoorLockSetPinOrIdStatus value) { @@ -5237,6 +9400,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5249,6 +9428,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPDoorLockClusterDoorLockUserStatusAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::DoorLock::DoorLockUserStatus value) { @@ -5257,6 +9453,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPDoorLockClusterDoorLockUserStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableDoorLockClusterDoorLockUserStatusAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5269,6 +9481,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableDoorLockClusterDoorLockUserStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPDoorLockClusterDoorLockUserTypeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::DoorLock::DoorLockUserType value) { @@ -5277,6 +9505,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPDoorLockClusterDoorLockUserTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableDoorLockClusterDoorLockUserTypeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5289,6 +9533,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableDoorLockClusterDoorLockUserTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::PumpConfigurationAndControl::PumpControlMode value) { @@ -5297,6 +9557,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5306,8 +9583,26 @@ } else { objCValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(value.Value())]; } - DispatchSuccess(context, objCValue); -}; + DispatchSuccess(context, objCValue); +}; + +void CHIPNullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} void CHIPPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::PumpConfigurationAndControl::PumpOperationMode value) @@ -5317,6 +9612,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::Nullable & value) { @@ -5329,6 +9642,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast( + context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPThermostatClusterSetpointAdjustModeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::Thermostat::SetpointAdjustMode value) { @@ -5337,6 +9668,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPThermostatClusterSetpointAdjustModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableThermostatClusterSetpointAdjustModeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5349,6 +9696,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableThermostatClusterSetpointAdjustModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPColorControlClusterColorLoopActionAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::ColorControl::ColorLoopAction value) { @@ -5357,6 +9720,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPColorControlClusterColorLoopActionAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableColorControlClusterColorLoopActionAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5369,6 +9748,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableColorControlClusterColorLoopActionAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPColorControlClusterColorLoopDirectionAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::ColorControl::ColorLoopDirection value) { @@ -5377,6 +9772,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPColorControlClusterColorLoopDirectionAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableColorControlClusterColorLoopDirectionAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5389,6 +9800,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableColorControlClusterColorLoopDirectionAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPColorControlClusterColorModeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::ColorControl::ColorMode value) { @@ -5397,6 +9824,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPColorControlClusterColorModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableColorControlClusterColorModeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5409,6 +9852,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableColorControlClusterColorModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPColorControlClusterHueDirectionAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::ColorControl::HueDirection value) { @@ -5417,6 +9876,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPColorControlClusterHueDirectionAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableColorControlClusterHueDirectionAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5429,6 +9904,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableColorControlClusterHueDirectionAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPColorControlClusterHueMoveModeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::ColorControl::HueMoveMode value) { @@ -5437,6 +9928,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPColorControlClusterHueMoveModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableColorControlClusterHueMoveModeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5449,6 +9956,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableColorControlClusterHueMoveModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPColorControlClusterHueStepModeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::ColorControl::HueStepMode value) { @@ -5457,6 +9980,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPColorControlClusterHueStepModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableColorControlClusterHueStepModeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5469,6 +10008,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableColorControlClusterHueStepModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPColorControlClusterSaturationMoveModeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::ColorControl::SaturationMoveMode value) { @@ -5477,6 +10032,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPColorControlClusterSaturationMoveModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableColorControlClusterSaturationMoveModeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5489,6 +10060,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableColorControlClusterSaturationMoveModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPColorControlClusterSaturationStepModeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::ColorControl::SaturationStepMode value) { @@ -5497,6 +10084,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPColorControlClusterSaturationStepModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableColorControlClusterSaturationStepModeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5509,6 +10112,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableColorControlClusterSaturationStepModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::IlluminanceMeasurement::LightSensorType value) { @@ -5517,6 +10136,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5529,6 +10164,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPIasZoneClusterIasEnrollResponseCodeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::IasZone::IasEnrollResponseCode value) { @@ -5537,6 +10190,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPIasZoneClusterIasEnrollResponseCodeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableIasZoneClusterIasEnrollResponseCodeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5549,6 +10218,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableIasZoneClusterIasEnrollResponseCodeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPIasZoneClusterIasZoneTypeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::IasZone::IasZoneType value) { @@ -5557,6 +10242,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPIasZoneClusterIasZoneTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableIasZoneClusterIasZoneTypeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5569,6 +10270,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableIasZoneClusterIasZoneTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPIasAceClusterIasAceAlarmStatusAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::IasAce::IasAceAlarmStatus value) { @@ -5577,6 +10294,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPIasAceClusterIasAceAlarmStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableIasAceClusterIasAceAlarmStatusAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5589,6 +10322,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableIasAceClusterIasAceAlarmStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPIasAceClusterIasAceArmModeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::IasAce::IasAceArmMode value) { @@ -5597,6 +10346,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPIasAceClusterIasAceArmModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableIasAceClusterIasAceArmModeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5609,6 +10374,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableIasAceClusterIasAceArmModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPIasAceClusterIasAceArmNotificationAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::IasAce::IasAceArmNotification value) { @@ -5617,6 +10398,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPIasAceClusterIasAceArmNotificationAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableIasAceClusterIasAceArmNotificationAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5629,6 +10426,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableIasAceClusterIasAceArmNotificationAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPIasAceClusterIasAceAudibleNotificationAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::IasAce::IasAceAudibleNotification value) { @@ -5637,6 +10450,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPIasAceClusterIasAceAudibleNotificationAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableIasAceClusterIasAceAudibleNotificationAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5649,6 +10478,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableIasAceClusterIasAceAudibleNotificationAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPIasAceClusterIasAceBypassResultAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::IasAce::IasAceBypassResult value) { @@ -5657,6 +10503,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPIasAceClusterIasAceBypassResultAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableIasAceClusterIasAceBypassResultAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5669,6 +10531,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableIasAceClusterIasAceBypassResultAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPIasAceClusterIasAcePanelStatusAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::IasAce::IasAcePanelStatus value) { @@ -5677,6 +10555,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPIasAceClusterIasAcePanelStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableIasAceClusterIasAcePanelStatusAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5689,6 +10583,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableIasAceClusterIasAcePanelStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPIasAceClusterIasZoneTypeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::IasAce::IasZoneType value) { @@ -5697,6 +10607,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPIasAceClusterIasZoneTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableIasAceClusterIasZoneTypeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5709,6 +10635,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableIasAceClusterIasZoneTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPTvChannelClusterTvChannelErrorTypeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::TvChannel::TvChannelErrorType value) { @@ -5717,6 +10659,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPTvChannelClusterTvChannelErrorTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableTvChannelClusterTvChannelErrorTypeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5726,8 +10684,24 @@ } else { objCValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(value.Value())]; } - DispatchSuccess(context, objCValue); -}; + DispatchSuccess(context, objCValue); +}; + +void CHIPNullableTvChannelClusterTvChannelErrorTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} void CHIPTvChannelClusterTvChannelLineupInfoTypeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::TvChannel::TvChannelLineupInfoType value) @@ -5737,6 +10711,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPTvChannelClusterTvChannelLineupInfoTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableTvChannelClusterTvChannelLineupInfoTypeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5749,6 +10739,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableTvChannelClusterTvChannelLineupInfoTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPTargetNavigatorClusterNavigateTargetStatusAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::TargetNavigator::NavigateTargetStatus value) { @@ -5757,6 +10764,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPTargetNavigatorClusterNavigateTargetStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableTargetNavigatorClusterNavigateTargetStatusAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5769,6 +10792,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableTargetNavigatorClusterNavigateTargetStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPMediaPlaybackClusterMediaPlaybackStateAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::MediaPlayback::MediaPlaybackState value) { @@ -5777,6 +10817,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPMediaPlaybackClusterMediaPlaybackStateAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableMediaPlaybackClusterMediaPlaybackStateAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5789,6 +10845,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableMediaPlaybackClusterMediaPlaybackStateAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPMediaPlaybackClusterMediaPlaybackStatusAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::MediaPlayback::MediaPlaybackStatus value) { @@ -5797,6 +10870,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPMediaPlaybackClusterMediaPlaybackStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableMediaPlaybackClusterMediaPlaybackStatusAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5809,6 +10898,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableMediaPlaybackClusterMediaPlaybackStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPMediaInputClusterMediaInputTypeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::MediaInput::MediaInputType value) { @@ -5817,6 +10923,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPMediaInputClusterMediaInputTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableMediaInputClusterMediaInputTypeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5829,6 +10951,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableMediaInputClusterMediaInputTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPKeypadInputClusterKeypadInputCecKeyCodeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::KeypadInput::KeypadInputCecKeyCode value) { @@ -5837,6 +10975,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPKeypadInputClusterKeypadInputCecKeyCodeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableKeypadInputClusterKeypadInputCecKeyCodeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5849,6 +11003,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableKeypadInputClusterKeypadInputCecKeyCodeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPKeypadInputClusterKeypadInputStatusAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::KeypadInput::KeypadInputStatus value) { @@ -5857,6 +11028,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPKeypadInputClusterKeypadInputStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableKeypadInputClusterKeypadInputStatusAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5869,6 +11056,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableKeypadInputClusterKeypadInputStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPContentLauncherClusterContentLaunchMetricTypeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::ContentLauncher::ContentLaunchMetricType value) { @@ -5877,6 +11080,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPContentLauncherClusterContentLaunchMetricTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableContentLauncherClusterContentLaunchMetricTypeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5889,6 +11108,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableContentLauncherClusterContentLaunchMetricTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPContentLauncherClusterContentLaunchParameterEnumAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::ContentLauncher::ContentLaunchParameterEnum value) { @@ -5897,6 +11134,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPContentLauncherClusterContentLaunchParameterEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableContentLauncherClusterContentLaunchParameterEnumAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5909,6 +11163,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableContentLauncherClusterContentLaunchParameterEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPContentLauncherClusterContentLaunchStatusAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::ContentLauncher::ContentLaunchStatus value) { @@ -5917,6 +11189,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPContentLauncherClusterContentLaunchStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableContentLauncherClusterContentLaunchStatusAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5929,6 +11217,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableContentLauncherClusterContentLaunchStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPContentLauncherClusterContentLaunchStreamingTypeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::ContentLauncher::ContentLaunchStreamingType value) { @@ -5937,6 +11242,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPContentLauncherClusterContentLaunchStreamingTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableContentLauncherClusterContentLaunchStreamingTypeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5949,6 +11271,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableContentLauncherClusterContentLaunchStreamingTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPAudioOutputClusterAudioOutputTypeAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::AudioOutput::AudioOutputType value) { @@ -5957,6 +11297,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPAudioOutputClusterAudioOutputTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableAudioOutputClusterAudioOutputTypeAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -5969,6 +11325,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableAudioOutputClusterAudioOutputTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPApplicationLauncherClusterApplicationLauncherStatusAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::ApplicationLauncher::ApplicationLauncherStatus value) { @@ -5977,6 +11349,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPApplicationLauncherClusterApplicationLauncherStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableApplicationLauncherClusterApplicationLauncherStatusAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::Nullable & value) { @@ -5989,6 +11379,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableApplicationLauncherClusterApplicationLauncherStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast( + context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPApplicationBasicClusterApplicationBasicStatusAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::ApplicationBasic::ApplicationBasicStatus value) { @@ -5997,6 +11405,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPApplicationBasicClusterApplicationBasicStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableApplicationBasicClusterApplicationBasicStatusAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -6009,6 +11433,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableApplicationBasicClusterApplicationBasicStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPTestClusterClusterSimpleEnumAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::TestCluster::SimpleEnum value) { @@ -6017,6 +11459,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableTestClusterClusterSimpleEnumAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -6029,6 +11487,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPMessagingClusterEventIdAttributeCallbackBridge::OnSuccessFn(void * context, chip::app::Clusters::Messaging::EventId value) { NSNumber * _Nonnull objCValue; @@ -6036,6 +11510,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPMessagingClusterEventIdAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableMessagingClusterEventIdAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -6048,6 +11538,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableMessagingClusterEventIdAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPMessagingClusterMessagingControlConfirmationAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::Messaging::MessagingControlConfirmation value) { @@ -6056,6 +11562,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPMessagingClusterMessagingControlConfirmationAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableMessagingClusterMessagingControlConfirmationAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -6068,6 +11590,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableMessagingClusterMessagingControlConfirmationAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPMessagingClusterMessagingControlEnhancedConfirmationAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::Messaging::MessagingControlEnhancedConfirmation value) { @@ -6076,6 +11616,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPMessagingClusterMessagingControlEnhancedConfirmationAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableMessagingClusterMessagingControlEnhancedConfirmationAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::Nullable & value) { @@ -6088,6 +11646,25 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableMessagingClusterMessagingControlEnhancedConfirmationAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast( + context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPMessagingClusterMessagingControlImportanceAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::Messaging::MessagingControlImportance value) { @@ -6096,6 +11673,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPMessagingClusterMessagingControlImportanceAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableMessagingClusterMessagingControlImportanceAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -6108,6 +11701,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableMessagingClusterMessagingControlImportanceAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPMessagingClusterMessagingControlTransmissionAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::Messaging::MessagingControlTransmission value) { @@ -6116,6 +11726,22 @@ DispatchSuccess(context, objCValue); }; +void CHIPMessagingClusterMessagingControlTransmissionAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished(void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableMessagingClusterMessagingControlTransmissionAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -6128,6 +11754,24 @@ DispatchSuccess(context, objCValue); }; +void CHIPNullableMessagingClusterMessagingControlTransmissionAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPApplianceEventsAndAlertClusterEventIdentificationAttributeCallbackBridge::OnSuccessFn( void * context, chip::app::Clusters::ApplianceEventsAndAlert::EventIdentification value) { @@ -6136,6 +11780,23 @@ DispatchSuccess(context, objCValue); }; +void CHIPApplianceEventsAndAlertClusterEventIdentificationAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} + void CHIPNullableApplianceEventsAndAlertClusterEventIdentificationAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::Nullable & value) { @@ -6147,3 +11808,21 @@ } DispatchSuccess(context, objCValue); }; + +void CHIPNullableApplianceEventsAndAlertClusterEventIdentificationAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished( + void * context) +{ + auto * self + = static_cast(context); + if (!self->mQueue) { + return; + } + + if (self->mEstablishedHandler != nil) { + dispatch_async(self->mQueue, self->mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + self->mEstablishedHandler = nil; + } +} diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge_internal.h b/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge_internal.h index 48f408e1246a50..3dc1a35357382c 100644 --- a/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge_internal.h +++ b/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge_internal.h @@ -574,6 +574,21 @@ class CHIPOctetStringAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -584,6 +599,22 @@ class CHIPNullableOctetStringAttributeCallbackBridge : public CHIPCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable & value); }; +class CHIPNullableOctetStringAttributeCallbackSubscriptionBridge : public CHIPNullableOctetStringAttributeCallbackBridge +{ +public: + CHIPNullableOctetStringAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableOctetStringAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPCharStringAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -594,6 +625,21 @@ class CHIPCharStringAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -604,6 +650,22 @@ class CHIPNullableCharStringAttributeCallbackBridge : public CHIPCallbackBridge< static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable & value); }; +class CHIPNullableCharStringAttributeCallbackSubscriptionBridge : public CHIPNullableCharStringAttributeCallbackBridge +{ +public: + CHIPNullableCharStringAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableCharStringAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPBooleanAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -614,6 +676,21 @@ class CHIPBooleanAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -624,6 +701,21 @@ class CHIPNullableBooleanAttributeCallbackBridge : public CHIPCallbackBridge & value); }; +class CHIPNullableBooleanAttributeCallbackSubscriptionBridge : public CHIPNullableBooleanAttributeCallbackBridge +{ +public: + CHIPNullableBooleanAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableBooleanAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPInt8uAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -634,6 +726,21 @@ class CHIPInt8uAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -644,6 +751,21 @@ class CHIPNullableInt8uAttributeCallbackBridge : public CHIPCallbackBridge & value); }; +class CHIPNullableInt8uAttributeCallbackSubscriptionBridge : public CHIPNullableInt8uAttributeCallbackBridge +{ +public: + CHIPNullableInt8uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableInt8uAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPInt8sAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -654,6 +776,21 @@ class CHIPInt8sAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -664,6 +801,21 @@ class CHIPNullableInt8sAttributeCallbackBridge : public CHIPCallbackBridge & value); }; +class CHIPNullableInt8sAttributeCallbackSubscriptionBridge : public CHIPNullableInt8sAttributeCallbackBridge +{ +public: + CHIPNullableInt8sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableInt8sAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPInt16uAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -674,6 +826,21 @@ class CHIPInt16uAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -684,6 +851,21 @@ class CHIPNullableInt16uAttributeCallbackBridge : public CHIPCallbackBridge & value); }; +class CHIPNullableInt16uAttributeCallbackSubscriptionBridge : public CHIPNullableInt16uAttributeCallbackBridge +{ +public: + CHIPNullableInt16uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableInt16uAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPInt16sAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -694,6 +876,21 @@ class CHIPInt16sAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -704,6 +901,21 @@ class CHIPNullableInt16sAttributeCallbackBridge : public CHIPCallbackBridge & value); }; +class CHIPNullableInt16sAttributeCallbackSubscriptionBridge : public CHIPNullableInt16sAttributeCallbackBridge +{ +public: + CHIPNullableInt16sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableInt16sAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPInt32uAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -714,6 +926,21 @@ class CHIPInt32uAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -724,6 +951,21 @@ class CHIPNullableInt32uAttributeCallbackBridge : public CHIPCallbackBridge & value); }; +class CHIPNullableInt32uAttributeCallbackSubscriptionBridge : public CHIPNullableInt32uAttributeCallbackBridge +{ +public: + CHIPNullableInt32uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableInt32uAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPInt32sAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -734,6 +976,21 @@ class CHIPInt32sAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -744,6 +1001,21 @@ class CHIPNullableInt32sAttributeCallbackBridge : public CHIPCallbackBridge & value); }; +class CHIPNullableInt32sAttributeCallbackSubscriptionBridge : public CHIPNullableInt32sAttributeCallbackBridge +{ +public: + CHIPNullableInt32sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableInt32sAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPInt64uAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -754,6 +1026,21 @@ class CHIPInt64uAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -764,6 +1051,21 @@ class CHIPNullableInt64uAttributeCallbackBridge : public CHIPCallbackBridge & value); }; +class CHIPNullableInt64uAttributeCallbackSubscriptionBridge : public CHIPNullableInt64uAttributeCallbackBridge +{ +public: + CHIPNullableInt64uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableInt64uAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPInt64sAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -774,6 +1076,21 @@ class CHIPInt64sAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -784,6 +1101,21 @@ class CHIPNullableInt64sAttributeCallbackBridge : public CHIPCallbackBridge & value); }; +class CHIPNullableInt64sAttributeCallbackSubscriptionBridge : public CHIPNullableInt64sAttributeCallbackBridge +{ +public: + CHIPNullableInt64sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableInt64sAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPFloatAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -794,6 +1126,21 @@ class CHIPFloatAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -804,6 +1151,21 @@ class CHIPNullableFloatAttributeCallbackBridge : public CHIPCallbackBridge & value); }; +class CHIPNullableFloatAttributeCallbackSubscriptionBridge : public CHIPNullableFloatAttributeCallbackBridge +{ +public: + CHIPNullableFloatAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableFloatAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPDoubleAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -814,6 +1176,21 @@ class CHIPDoubleAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -824,6 +1201,21 @@ class CHIPNullableDoubleAttributeCallbackBridge : public CHIPCallbackBridge & value); }; +class CHIPNullableDoubleAttributeCallbackSubscriptionBridge : public CHIPNullableDoubleAttributeCallbackBridge +{ +public: + CHIPNullableDoubleAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableDoubleAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPVendorIdAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -834,6 +1226,21 @@ class CHIPVendorIdAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -844,6 +1251,21 @@ class CHIPNullableVendorIdAttributeCallbackBridge : public CHIPCallbackBridge & value); }; +class CHIPNullableVendorIdAttributeCallbackSubscriptionBridge : public CHIPNullableVendorIdAttributeCallbackBridge +{ +public: + CHIPNullableVendorIdAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableVendorIdAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPAccessControlAclListAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -857,6 +1279,22 @@ class CHIPAccessControlAclListAttributeCallbackBridge : public CHIPCallbackBridg value); }; +class CHIPAccessControlAclListAttributeCallbackSubscriptionBridge : public CHIPAccessControlAclListAttributeCallbackBridge +{ +public: + CHIPAccessControlAclListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPAccessControlAclListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPAccessControlExtensionListAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -870,6 +1308,23 @@ class CHIPAccessControlExtensionListAttributeCallbackBridge : public CHIPCallbac value); }; +class CHIPAccessControlExtensionListAttributeCallbackSubscriptionBridge + : public CHIPAccessControlExtensionListAttributeCallbackBridge +{ +public: + CHIPAccessControlExtensionListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPAccessControlExtensionListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPAccessControlAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -881,6 +1336,23 @@ class CHIPAccessControlAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPAccessControlAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPAccessControlAttributeListListAttributeCallbackBridge +{ +public: + CHIPAccessControlAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPAccessControlAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPAccountLoginAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -892,6 +1364,23 @@ class CHIPAccountLoginAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPAccountLoginAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPAccountLoginAttributeListListAttributeCallbackBridge +{ +public: + CHIPAccountLoginAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPAccountLoginAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPAdministratorCommissioningAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -904,6 +1393,23 @@ class CHIPAdministratorCommissioningAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPAdministratorCommissioningAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPAdministratorCommissioningAttributeListListAttributeCallbackBridge +{ +public: + CHIPAdministratorCommissioningAttributeListListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPAdministratorCommissioningAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPApplicationBasicAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -915,6 +1421,23 @@ class CHIPApplicationBasicAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPApplicationBasicAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPApplicationBasicAttributeListListAttributeCallbackBridge +{ +public: + CHIPApplicationBasicAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPApplicationBasicAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPApplicationLauncherApplicationLauncherListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -927,6 +1450,23 @@ class CHIPApplicationLauncherApplicationLauncherListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPApplicationLauncherApplicationLauncherListListAttributeCallbackSubscriptionBridge + : public CHIPApplicationLauncherApplicationLauncherListListAttributeCallbackBridge +{ +public: + CHIPApplicationLauncherApplicationLauncherListListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPApplicationLauncherApplicationLauncherListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPApplicationLauncherAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -938,6 +1478,23 @@ class CHIPApplicationLauncherAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPApplicationLauncherAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPApplicationLauncherAttributeListListAttributeCallbackBridge +{ +public: + CHIPApplicationLauncherAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPApplicationLauncherAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPAudioOutputAudioOutputListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -952,6 +1509,23 @@ class CHIPAudioOutputAudioOutputListListAttributeCallbackBridge value); }; +class CHIPAudioOutputAudioOutputListListAttributeCallbackSubscriptionBridge + : public CHIPAudioOutputAudioOutputListListAttributeCallbackBridge +{ +public: + CHIPAudioOutputAudioOutputListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPAudioOutputAudioOutputListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPAudioOutputAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -963,6 +1537,23 @@ class CHIPAudioOutputAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPAudioOutputAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPAudioOutputAttributeListListAttributeCallbackBridge +{ +public: + CHIPAudioOutputAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPAudioOutputAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPBarrierControlAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -974,6 +1565,23 @@ class CHIPBarrierControlAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPBarrierControlAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPBarrierControlAttributeListListAttributeCallbackBridge +{ +public: + CHIPBarrierControlAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPBarrierControlAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPBasicAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -984,6 +1592,22 @@ class CHIPBasicAttributeListListAttributeCallbackBridge : public CHIPCallbackBri static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPBasicAttributeListListAttributeCallbackSubscriptionBridge : public CHIPBasicAttributeListListAttributeCallbackBridge +{ +public: + CHIPBasicAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPBasicAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPBinaryInputBasicAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -995,6 +1619,23 @@ class CHIPBinaryInputBasicAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPBinaryInputBasicAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPBinaryInputBasicAttributeListListAttributeCallbackBridge +{ +public: + CHIPBinaryInputBasicAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPBinaryInputBasicAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPBindingAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -1005,6 +1646,22 @@ class CHIPBindingAttributeListListAttributeCallbackBridge : public CHIPCallbackB static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPBindingAttributeListListAttributeCallbackSubscriptionBridge : public CHIPBindingAttributeListListAttributeCallbackBridge +{ +public: + CHIPBindingAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPBindingAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPBooleanStateAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1016,6 +1673,23 @@ class CHIPBooleanStateAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPBooleanStateAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPBooleanStateAttributeListListAttributeCallbackBridge +{ +public: + CHIPBooleanStateAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPBooleanStateAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPBridgedActionsActionListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1030,6 +1704,23 @@ class CHIPBridgedActionsActionListListAttributeCallbackBridge value); }; +class CHIPBridgedActionsActionListListAttributeCallbackSubscriptionBridge + : public CHIPBridgedActionsActionListListAttributeCallbackBridge +{ +public: + CHIPBridgedActionsActionListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPBridgedActionsActionListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPBridgedActionsEndpointListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1044,6 +1735,23 @@ class CHIPBridgedActionsEndpointListListAttributeCallbackBridge value); }; +class CHIPBridgedActionsEndpointListListAttributeCallbackSubscriptionBridge + : public CHIPBridgedActionsEndpointListListAttributeCallbackBridge +{ +public: + CHIPBridgedActionsEndpointListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPBridgedActionsEndpointListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPBridgedActionsAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1055,6 +1763,23 @@ class CHIPBridgedActionsAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPBridgedActionsAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPBridgedActionsAttributeListListAttributeCallbackBridge +{ +public: + CHIPBridgedActionsAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPBridgedActionsAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPBridgedDeviceBasicAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1066,6 +1791,23 @@ class CHIPBridgedDeviceBasicAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPBridgedDeviceBasicAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPBridgedDeviceBasicAttributeListListAttributeCallbackBridge +{ +public: + CHIPBridgedDeviceBasicAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPBridgedDeviceBasicAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPColorControlAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1077,6 +1819,23 @@ class CHIPColorControlAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPColorControlAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPColorControlAttributeListListAttributeCallbackBridge +{ +public: + CHIPColorControlAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPColorControlAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPContentLauncherAcceptsHeaderListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1088,6 +1847,23 @@ class CHIPContentLauncherAcceptsHeaderListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPContentLauncherAcceptsHeaderListListAttributeCallbackSubscriptionBridge + : public CHIPContentLauncherAcceptsHeaderListListAttributeCallbackBridge +{ +public: + CHIPContentLauncherAcceptsHeaderListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPContentLauncherAcceptsHeaderListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPContentLauncherSupportedStreamingTypesListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1102,6 +1878,23 @@ class CHIPContentLauncherSupportedStreamingTypesListAttributeCallbackBridge const chip::app::DataModel::DecodableList & value); }; +class CHIPContentLauncherSupportedStreamingTypesListAttributeCallbackSubscriptionBridge + : public CHIPContentLauncherSupportedStreamingTypesListAttributeCallbackBridge +{ +public: + CHIPContentLauncherSupportedStreamingTypesListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPContentLauncherSupportedStreamingTypesListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPContentLauncherAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1113,6 +1906,23 @@ class CHIPContentLauncherAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPContentLauncherAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPContentLauncherAttributeListListAttributeCallbackBridge +{ +public: + CHIPContentLauncherAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPContentLauncherAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPDescriptorDeviceListListAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -1125,6 +1935,22 @@ class CHIPDescriptorDeviceListListAttributeCallbackBridge : public CHIPCallbackB const chip::app::DataModel::DecodableList & value); }; +class CHIPDescriptorDeviceListListAttributeCallbackSubscriptionBridge : public CHIPDescriptorDeviceListListAttributeCallbackBridge +{ +public: + CHIPDescriptorDeviceListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPDescriptorDeviceListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPDescriptorServerListListAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -1135,6 +1961,22 @@ class CHIPDescriptorServerListListAttributeCallbackBridge : public CHIPCallbackB static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPDescriptorServerListListAttributeCallbackSubscriptionBridge : public CHIPDescriptorServerListListAttributeCallbackBridge +{ +public: + CHIPDescriptorServerListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPDescriptorServerListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPDescriptorClientListListAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -1145,6 +1987,22 @@ class CHIPDescriptorClientListListAttributeCallbackBridge : public CHIPCallbackB static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPDescriptorClientListListAttributeCallbackSubscriptionBridge : public CHIPDescriptorClientListListAttributeCallbackBridge +{ +public: + CHIPDescriptorClientListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPDescriptorClientListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPDescriptorPartsListListAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -1155,6 +2013,22 @@ class CHIPDescriptorPartsListListAttributeCallbackBridge : public CHIPCallbackBr static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPDescriptorPartsListListAttributeCallbackSubscriptionBridge : public CHIPDescriptorPartsListListAttributeCallbackBridge +{ +public: + CHIPDescriptorPartsListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPDescriptorPartsListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPDescriptorAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1166,6 +2040,23 @@ class CHIPDescriptorAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPDescriptorAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPDescriptorAttributeListListAttributeCallbackBridge +{ +public: + CHIPDescriptorAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPDescriptorAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPDiagnosticLogsAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1177,6 +2068,23 @@ class CHIPDiagnosticLogsAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPDiagnosticLogsAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPDiagnosticLogsAttributeListListAttributeCallbackBridge +{ +public: + CHIPDiagnosticLogsAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPDiagnosticLogsAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPDoorLockAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -1187,6 +2095,22 @@ class CHIPDoorLockAttributeListListAttributeCallbackBridge : public CHIPCallback static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPDoorLockAttributeListListAttributeCallbackSubscriptionBridge : public CHIPDoorLockAttributeListListAttributeCallbackBridge +{ +public: + CHIPDoorLockAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPDoorLockAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPElectricalMeasurementAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1199,6 +2123,23 @@ class CHIPElectricalMeasurementAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPElectricalMeasurementAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPElectricalMeasurementAttributeListListAttributeCallbackBridge +{ +public: + CHIPElectricalMeasurementAttributeListListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPElectricalMeasurementAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPEthernetNetworkDiagnosticsAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1211,6 +2152,23 @@ class CHIPEthernetNetworkDiagnosticsAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPEthernetNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPEthernetNetworkDiagnosticsAttributeListListAttributeCallbackBridge +{ +public: + CHIPEthernetNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPEthernetNetworkDiagnosticsAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPFixedLabelLabelListListAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -1223,6 +2181,22 @@ class CHIPFixedLabelLabelListListAttributeCallbackBridge : public CHIPCallbackBr const chip::app::DataModel::DecodableList & value); }; +class CHIPFixedLabelLabelListListAttributeCallbackSubscriptionBridge : public CHIPFixedLabelLabelListListAttributeCallbackBridge +{ +public: + CHIPFixedLabelLabelListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPFixedLabelLabelListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPFixedLabelAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1234,6 +2208,23 @@ class CHIPFixedLabelAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPFixedLabelAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPFixedLabelAttributeListListAttributeCallbackBridge +{ +public: + CHIPFixedLabelAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPFixedLabelAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPFlowMeasurementAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1245,6 +2236,23 @@ class CHIPFlowMeasurementAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPFlowMeasurementAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPFlowMeasurementAttributeListListAttributeCallbackBridge +{ +public: + CHIPFlowMeasurementAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPFlowMeasurementAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPGeneralCommissioningBasicCommissioningInfoListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1260,6 +2268,23 @@ class CHIPGeneralCommissioningBasicCommissioningInfoListListAttributeCallbackBri chip::app::Clusters::GeneralCommissioning::Structs::BasicCommissioningInfoType::DecodableType> & value); }; +class CHIPGeneralCommissioningBasicCommissioningInfoListListAttributeCallbackSubscriptionBridge + : public CHIPGeneralCommissioningBasicCommissioningInfoListListAttributeCallbackBridge +{ +public: + CHIPGeneralCommissioningBasicCommissioningInfoListListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPGeneralCommissioningBasicCommissioningInfoListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPGeneralCommissioningAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1272,6 +2297,23 @@ class CHIPGeneralCommissioningAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPGeneralCommissioningAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPGeneralCommissioningAttributeListListAttributeCallbackBridge +{ +public: + CHIPGeneralCommissioningAttributeListListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPGeneralCommissioningAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPGeneralDiagnosticsNetworkInterfacesListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1286,6 +2328,23 @@ class CHIPGeneralDiagnosticsNetworkInterfacesListAttributeCallbackBridge chip::app::Clusters::GeneralDiagnostics::Structs::NetworkInterfaceType::DecodableType> & value); }; +class CHIPGeneralDiagnosticsNetworkInterfacesListAttributeCallbackSubscriptionBridge + : public CHIPGeneralDiagnosticsNetworkInterfacesListAttributeCallbackBridge +{ +public: + CHIPGeneralDiagnosticsNetworkInterfacesListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPGeneralDiagnosticsNetworkInterfacesListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1298,6 +2357,23 @@ class CHIPGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackSubscriptionBridge + : public CHIPGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackBridge +{ +public: + CHIPGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1310,6 +2386,23 @@ class CHIPGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackSubscriptionBridge + : public CHIPGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackBridge +{ +public: + CHIPGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1322,6 +2415,23 @@ class CHIPGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackSubscriptionBridge + : public CHIPGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackBridge +{ +public: + CHIPGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPGeneralDiagnosticsAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1333,6 +2443,23 @@ class CHIPGeneralDiagnosticsAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPGeneralDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPGeneralDiagnosticsAttributeListListAttributeCallbackBridge +{ +public: + CHIPGeneralDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPGeneralDiagnosticsAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPGroupKeyManagementGroupsListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1347,6 +2474,23 @@ class CHIPGroupKeyManagementGroupsListAttributeCallbackBridge value); }; +class CHIPGroupKeyManagementGroupsListAttributeCallbackSubscriptionBridge + : public CHIPGroupKeyManagementGroupsListAttributeCallbackBridge +{ +public: + CHIPGroupKeyManagementGroupsListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPGroupKeyManagementGroupsListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPGroupKeyManagementGroupKeysListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1361,6 +2505,23 @@ class CHIPGroupKeyManagementGroupKeysListAttributeCallbackBridge value); }; +class CHIPGroupKeyManagementGroupKeysListAttributeCallbackSubscriptionBridge + : public CHIPGroupKeyManagementGroupKeysListAttributeCallbackBridge +{ +public: + CHIPGroupKeyManagementGroupKeysListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPGroupKeyManagementGroupKeysListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPGroupKeyManagementAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1372,6 +2533,23 @@ class CHIPGroupKeyManagementAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPGroupKeyManagementAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPGroupKeyManagementAttributeListListAttributeCallbackBridge +{ +public: + CHIPGroupKeyManagementAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPGroupKeyManagementAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPGroupsAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -1382,6 +2560,22 @@ class CHIPGroupsAttributeListListAttributeCallbackBridge : public CHIPCallbackBr static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPGroupsAttributeListListAttributeCallbackSubscriptionBridge : public CHIPGroupsAttributeListListAttributeCallbackBridge +{ +public: + CHIPGroupsAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPGroupsAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPIdentifyAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -1392,6 +2586,22 @@ class CHIPIdentifyAttributeListListAttributeCallbackBridge : public CHIPCallback static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPIdentifyAttributeListListAttributeCallbackSubscriptionBridge : public CHIPIdentifyAttributeListListAttributeCallbackBridge +{ +public: + CHIPIdentifyAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPIdentifyAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPIlluminanceMeasurementAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1404,6 +2614,23 @@ class CHIPIlluminanceMeasurementAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPIlluminanceMeasurementAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPIlluminanceMeasurementAttributeListListAttributeCallbackBridge +{ +public: + CHIPIlluminanceMeasurementAttributeListListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPIlluminanceMeasurementAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPKeypadInputAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1415,6 +2642,23 @@ class CHIPKeypadInputAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPKeypadInputAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPKeypadInputAttributeListListAttributeCallbackBridge +{ +public: + CHIPKeypadInputAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPKeypadInputAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPLevelControlAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1426,6 +2670,23 @@ class CHIPLevelControlAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPLevelControlAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPLevelControlAttributeListListAttributeCallbackBridge +{ +public: + CHIPLevelControlAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPLevelControlAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPLowPowerAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -1436,6 +2697,22 @@ class CHIPLowPowerAttributeListListAttributeCallbackBridge : public CHIPCallback static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPLowPowerAttributeListListAttributeCallbackSubscriptionBridge : public CHIPLowPowerAttributeListListAttributeCallbackBridge +{ +public: + CHIPLowPowerAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPLowPowerAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPMediaInputMediaInputListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1449,6 +2726,23 @@ class CHIPMediaInputMediaInputListListAttributeCallbackBridge const chip::app::DataModel::DecodableList & value); }; +class CHIPMediaInputMediaInputListListAttributeCallbackSubscriptionBridge + : public CHIPMediaInputMediaInputListListAttributeCallbackBridge +{ +public: + CHIPMediaInputMediaInputListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPMediaInputMediaInputListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPMediaInputAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1460,6 +2754,23 @@ class CHIPMediaInputAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPMediaInputAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPMediaInputAttributeListListAttributeCallbackBridge +{ +public: + CHIPMediaInputAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPMediaInputAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPMediaPlaybackAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1471,6 +2782,23 @@ class CHIPMediaPlaybackAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPMediaPlaybackAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPMediaPlaybackAttributeListListAttributeCallbackBridge +{ +public: + CHIPMediaPlaybackAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPMediaPlaybackAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPModeSelectSupportedModesListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1485,6 +2813,23 @@ class CHIPModeSelectSupportedModesListAttributeCallbackBridge value); }; +class CHIPModeSelectSupportedModesListAttributeCallbackSubscriptionBridge + : public CHIPModeSelectSupportedModesListAttributeCallbackBridge +{ +public: + CHIPModeSelectSupportedModesListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPModeSelectSupportedModesListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPModeSelectAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1496,6 +2841,23 @@ class CHIPModeSelectAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPModeSelectAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPModeSelectAttributeListListAttributeCallbackBridge +{ +public: + CHIPModeSelectAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPModeSelectAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNetworkCommissioningAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1508,6 +2870,23 @@ class CHIPNetworkCommissioningAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPNetworkCommissioningAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPNetworkCommissioningAttributeListListAttributeCallbackBridge +{ +public: + CHIPNetworkCommissioningAttributeListListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNetworkCommissioningAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPOtaSoftwareUpdateProviderAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1520,6 +2899,23 @@ class CHIPOtaSoftwareUpdateProviderAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPOtaSoftwareUpdateProviderAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPOtaSoftwareUpdateProviderAttributeListListAttributeCallbackBridge +{ +public: + CHIPOtaSoftwareUpdateProviderAttributeListListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPOtaSoftwareUpdateProviderAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPOtaSoftwareUpdateRequestorAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1532,6 +2928,23 @@ class CHIPOtaSoftwareUpdateRequestorAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPOtaSoftwareUpdateRequestorAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPOtaSoftwareUpdateRequestorAttributeListListAttributeCallbackBridge +{ +public: + CHIPOtaSoftwareUpdateRequestorAttributeListListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPOtaSoftwareUpdateRequestorAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPOccupancySensingAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1543,6 +2956,23 @@ class CHIPOccupancySensingAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPOccupancySensingAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPOccupancySensingAttributeListListAttributeCallbackBridge +{ +public: + CHIPOccupancySensingAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPOccupancySensingAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPOnOffAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -1553,6 +2983,22 @@ class CHIPOnOffAttributeListListAttributeCallbackBridge : public CHIPCallbackBri static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPOnOffAttributeListListAttributeCallbackSubscriptionBridge : public CHIPOnOffAttributeListListAttributeCallbackBridge +{ +public: + CHIPOnOffAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPOnOffAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPOnOffSwitchConfigurationAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1565,6 +3011,23 @@ class CHIPOnOffSwitchConfigurationAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPOnOffSwitchConfigurationAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPOnOffSwitchConfigurationAttributeListListAttributeCallbackBridge +{ +public: + CHIPOnOffSwitchConfigurationAttributeListListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPOnOffSwitchConfigurationAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPOperationalCredentialsFabricsListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1579,6 +3042,23 @@ class CHIPOperationalCredentialsFabricsListListAttributeCallbackBridge chip::app::Clusters::OperationalCredentials::Structs::FabricDescriptor::DecodableType> & value); }; +class CHIPOperationalCredentialsFabricsListListAttributeCallbackSubscriptionBridge + : public CHIPOperationalCredentialsFabricsListListAttributeCallbackBridge +{ +public: + CHIPOperationalCredentialsFabricsListListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPOperationalCredentialsFabricsListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPOperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1591,6 +3071,23 @@ class CHIPOperationalCredentialsTrustedRootCertificatesListAttributeCallbackBrid static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPOperationalCredentialsTrustedRootCertificatesListAttributeCallbackSubscriptionBridge + : public CHIPOperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge +{ +public: + CHIPOperationalCredentialsTrustedRootCertificatesListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPOperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPOperationalCredentialsAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1600,7 +3097,24 @@ class CHIPOperationalCredentialsAttributeListListAttributeCallbackBridge CHIPCallbackBridge(queue, handler, action, OnSuccessFn, keepAlive){}; - static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); + static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); +}; + +class CHIPOperationalCredentialsAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPOperationalCredentialsAttributeListListAttributeCallbackBridge +{ +public: + CHIPOperationalCredentialsAttributeListListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPOperationalCredentialsAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; }; class CHIPPowerSourceActiveBatteryFaultsListAttributeCallbackBridge @@ -1614,6 +3128,23 @@ class CHIPPowerSourceActiveBatteryFaultsListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPPowerSourceActiveBatteryFaultsListAttributeCallbackSubscriptionBridge + : public CHIPPowerSourceActiveBatteryFaultsListAttributeCallbackBridge +{ +public: + CHIPPowerSourceActiveBatteryFaultsListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPPowerSourceActiveBatteryFaultsListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPPowerSourceAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1625,6 +3156,23 @@ class CHIPPowerSourceAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPPowerSourceAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPPowerSourceAttributeListListAttributeCallbackBridge +{ +public: + CHIPPowerSourceAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPPowerSourceAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPPowerSourceConfigurationSourcesListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1636,6 +3184,23 @@ class CHIPPowerSourceConfigurationSourcesListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPPowerSourceConfigurationSourcesListAttributeCallbackSubscriptionBridge + : public CHIPPowerSourceConfigurationSourcesListAttributeCallbackBridge +{ +public: + CHIPPowerSourceConfigurationSourcesListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPPowerSourceConfigurationSourcesListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPPowerSourceConfigurationAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1648,6 +3213,23 @@ class CHIPPowerSourceConfigurationAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPPowerSourceConfigurationAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPPowerSourceConfigurationAttributeListListAttributeCallbackBridge +{ +public: + CHIPPowerSourceConfigurationAttributeListListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPPowerSourceConfigurationAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPPressureMeasurementAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1659,6 +3241,23 @@ class CHIPPressureMeasurementAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPPressureMeasurementAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPPressureMeasurementAttributeListListAttributeCallbackBridge +{ +public: + CHIPPressureMeasurementAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPPressureMeasurementAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPPumpConfigurationAndControlAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1671,6 +3270,23 @@ class CHIPPumpConfigurationAndControlAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPPumpConfigurationAndControlAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPPumpConfigurationAndControlAttributeListListAttributeCallbackBridge +{ +public: + CHIPPumpConfigurationAndControlAttributeListListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPPumpConfigurationAndControlAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPRelativeHumidityMeasurementAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1683,6 +3299,23 @@ class CHIPRelativeHumidityMeasurementAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPRelativeHumidityMeasurementAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPRelativeHumidityMeasurementAttributeListListAttributeCallbackBridge +{ +public: + CHIPRelativeHumidityMeasurementAttributeListListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPRelativeHumidityMeasurementAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPScenesAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -1693,6 +3326,22 @@ class CHIPScenesAttributeListListAttributeCallbackBridge : public CHIPCallbackBr static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPScenesAttributeListListAttributeCallbackSubscriptionBridge : public CHIPScenesAttributeListListAttributeCallbackBridge +{ +public: + CHIPScenesAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPScenesAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPSoftwareDiagnosticsThreadMetricsListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1707,6 +3356,23 @@ class CHIPSoftwareDiagnosticsThreadMetricsListAttributeCallbackBridge value); }; +class CHIPSoftwareDiagnosticsThreadMetricsListAttributeCallbackSubscriptionBridge + : public CHIPSoftwareDiagnosticsThreadMetricsListAttributeCallbackBridge +{ +public: + CHIPSoftwareDiagnosticsThreadMetricsListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPSoftwareDiagnosticsThreadMetricsListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPSoftwareDiagnosticsAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1718,6 +3384,23 @@ class CHIPSoftwareDiagnosticsAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPSoftwareDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPSoftwareDiagnosticsAttributeListListAttributeCallbackBridge +{ +public: + CHIPSoftwareDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPSoftwareDiagnosticsAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPSwitchAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -1728,6 +3411,22 @@ class CHIPSwitchAttributeListListAttributeCallbackBridge : public CHIPCallbackBr static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPSwitchAttributeListListAttributeCallbackSubscriptionBridge : public CHIPSwitchAttributeListListAttributeCallbackBridge +{ +public: + CHIPSwitchAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPSwitchAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPTvChannelTvChannelListListAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -1740,6 +3439,23 @@ class CHIPTvChannelTvChannelListListAttributeCallbackBridge : public CHIPCallbac const chip::app::DataModel::DecodableList & value); }; +class CHIPTvChannelTvChannelListListAttributeCallbackSubscriptionBridge + : public CHIPTvChannelTvChannelListListAttributeCallbackBridge +{ +public: + CHIPTvChannelTvChannelListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPTvChannelTvChannelListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPTvChannelAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -1750,6 +3466,23 @@ class CHIPTvChannelAttributeListListAttributeCallbackBridge : public CHIPCallbac static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPTvChannelAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPTvChannelAttributeListListAttributeCallbackBridge +{ +public: + CHIPTvChannelAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPTvChannelAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPTargetNavigatorTargetNavigatorListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1764,6 +3497,23 @@ class CHIPTargetNavigatorTargetNavigatorListListAttributeCallbackBridge chip::app::Clusters::TargetNavigator::Structs::NavigateTargetTargetInfo::DecodableType> & value); }; +class CHIPTargetNavigatorTargetNavigatorListListAttributeCallbackSubscriptionBridge + : public CHIPTargetNavigatorTargetNavigatorListListAttributeCallbackBridge +{ +public: + CHIPTargetNavigatorTargetNavigatorListListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPTargetNavigatorTargetNavigatorListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPTargetNavigatorAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1775,6 +3525,23 @@ class CHIPTargetNavigatorAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPTargetNavigatorAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPTargetNavigatorAttributeListListAttributeCallbackBridge +{ +public: + CHIPTargetNavigatorAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPTargetNavigatorAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPTemperatureMeasurementAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1787,6 +3554,23 @@ class CHIPTemperatureMeasurementAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPTemperatureMeasurementAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPTemperatureMeasurementAttributeListListAttributeCallbackBridge +{ +public: + CHIPTemperatureMeasurementAttributeListListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPTemperatureMeasurementAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPTestClusterListInt8uListAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -1797,6 +3581,22 @@ class CHIPTestClusterListInt8uListAttributeCallbackBridge : public CHIPCallbackB static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPTestClusterListInt8uListAttributeCallbackSubscriptionBridge : public CHIPTestClusterListInt8uListAttributeCallbackBridge +{ +public: + CHIPTestClusterListInt8uListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPTestClusterListInt8uListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPTestClusterListOctetStringListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1808,6 +3608,23 @@ class CHIPTestClusterListOctetStringListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPTestClusterListOctetStringListAttributeCallbackSubscriptionBridge + : public CHIPTestClusterListOctetStringListAttributeCallbackBridge +{ +public: + CHIPTestClusterListOctetStringListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPTestClusterListOctetStringListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPTestClusterListStructOctetStringListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1822,6 +3639,23 @@ class CHIPTestClusterListStructOctetStringListAttributeCallbackBridge value); }; +class CHIPTestClusterListStructOctetStringListAttributeCallbackSubscriptionBridge + : public CHIPTestClusterListStructOctetStringListAttributeCallbackBridge +{ +public: + CHIPTestClusterListStructOctetStringListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPTestClusterListStructOctetStringListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1836,6 +3670,23 @@ class CHIPTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge chip::app::Clusters::TestCluster::Structs::NullablesAndOptionalsStruct::DecodableType> & value); }; +class CHIPTestClusterListNullablesAndOptionalsStructListAttributeCallbackSubscriptionBridge + : public CHIPTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge +{ +public: + CHIPTestClusterListNullablesAndOptionalsStructListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPTestClusterListLongOctetStringListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1847,6 +3698,23 @@ class CHIPTestClusterListLongOctetStringListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPTestClusterListLongOctetStringListAttributeCallbackSubscriptionBridge + : public CHIPTestClusterListLongOctetStringListAttributeCallbackBridge +{ +public: + CHIPTestClusterListLongOctetStringListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPTestClusterListLongOctetStringListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPTestClusterAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1858,6 +3726,23 @@ class CHIPTestClusterAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPTestClusterAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPTestClusterAttributeListListAttributeCallbackBridge +{ +public: + CHIPTestClusterAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPTestClusterAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPThermostatAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1869,6 +3754,23 @@ class CHIPThermostatAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPThermostatAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPThermostatAttributeListListAttributeCallbackBridge +{ +public: + CHIPThermostatAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPThermostatAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1883,6 +3785,23 @@ class CHIPThermostatUserInterfaceConfigurationAttributeListListAttributeCallback static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackBridge +{ +public: + CHIPThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1897,6 +3816,23 @@ class CHIPThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackBridge chip::app::Clusters::ThreadNetworkDiagnostics::Structs::NeighborTable::DecodableType> & value); }; +class CHIPThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackSubscriptionBridge + : public CHIPThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackBridge +{ +public: + CHIPThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPThreadNetworkDiagnosticsRouteTableListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1911,6 +3847,23 @@ class CHIPThreadNetworkDiagnosticsRouteTableListListAttributeCallbackBridge chip::app::Clusters::ThreadNetworkDiagnostics::Structs::RouteTable::DecodableType> & value); }; +class CHIPThreadNetworkDiagnosticsRouteTableListListAttributeCallbackSubscriptionBridge + : public CHIPThreadNetworkDiagnosticsRouteTableListListAttributeCallbackBridge +{ +public: + CHIPThreadNetworkDiagnosticsRouteTableListListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPThreadNetworkDiagnosticsRouteTableListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPThreadNetworkDiagnosticsSecurityPolicyListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1925,6 +3878,23 @@ class CHIPThreadNetworkDiagnosticsSecurityPolicyListAttributeCallbackBridge chip::app::Clusters::ThreadNetworkDiagnostics::Structs::SecurityPolicy::DecodableType> & value); }; +class CHIPThreadNetworkDiagnosticsSecurityPolicyListAttributeCallbackSubscriptionBridge + : public CHIPThreadNetworkDiagnosticsSecurityPolicyListAttributeCallbackBridge +{ +public: + CHIPThreadNetworkDiagnosticsSecurityPolicyListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPThreadNetworkDiagnosticsSecurityPolicyListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPThreadNetworkDiagnosticsOperationalDatasetComponentsListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1942,6 +3912,23 @@ class CHIPThreadNetworkDiagnosticsOperationalDatasetComponentsListAttributeCallb chip::app::Clusters::ThreadNetworkDiagnostics::Structs::OperationalDatasetComponents::DecodableType> & value); }; +class CHIPThreadNetworkDiagnosticsOperationalDatasetComponentsListAttributeCallbackSubscriptionBridge + : public CHIPThreadNetworkDiagnosticsOperationalDatasetComponentsListAttributeCallbackBridge +{ +public: + CHIPThreadNetworkDiagnosticsOperationalDatasetComponentsListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPThreadNetworkDiagnosticsOperationalDatasetComponentsListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1956,6 +3943,23 @@ class CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackBr const chip::app::DataModel::DecodableList & value); }; +class CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackSubscriptionBridge + : public CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackBridge +{ +public: + CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPThreadNetworkDiagnosticsAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1968,6 +3972,23 @@ class CHIPThreadNetworkDiagnosticsAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPThreadNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPThreadNetworkDiagnosticsAttributeListListAttributeCallbackBridge +{ +public: + CHIPThreadNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPThreadNetworkDiagnosticsAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPWakeOnLanAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -1978,6 +3999,23 @@ class CHIPWakeOnLanAttributeListListAttributeCallbackBridge : public CHIPCallbac static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPWakeOnLanAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPWakeOnLanAttributeListListAttributeCallbackBridge +{ +public: + CHIPWakeOnLanAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPWakeOnLanAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPWiFiNetworkDiagnosticsAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -1990,6 +4028,23 @@ class CHIPWiFiNetworkDiagnosticsAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPWiFiNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPWiFiNetworkDiagnosticsAttributeListListAttributeCallbackBridge +{ +public: + CHIPWiFiNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPWiFiNetworkDiagnosticsAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPWindowCoveringAttributeListListAttributeCallbackBridge : public CHIPCallbackBridge { @@ -2001,6 +4056,23 @@ class CHIPWindowCoveringAttributeListListAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); }; +class CHIPWindowCoveringAttributeListListAttributeCallbackSubscriptionBridge + : public CHIPWindowCoveringAttributeListListAttributeCallbackBridge +{ +public: + CHIPWindowCoveringAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPWindowCoveringAttributeListListAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPAccountLoginClusterGetSetupPINResponseCallbackBridge : public CHIPCallbackBridge { @@ -2783,6 +4855,23 @@ class CHIPIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::Identify::IdentifyEffectIdentifier value); }; +class CHIPIdentifyClusterIdentifyEffectIdentifierAttributeCallbackSubscriptionBridge + : public CHIPIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge +{ +public: + CHIPIdentifyClusterIdentifyEffectIdentifierAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge : public CHIPCallbackBridge { @@ -2796,6 +4885,23 @@ class CHIPNullableIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableIdentifyClusterIdentifyEffectIdentifierAttributeCallbackSubscriptionBridge + : public CHIPNullableIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge +{ +public: + CHIPNullableIdentifyClusterIdentifyEffectIdentifierAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge : public CHIPCallbackBridge { @@ -2807,6 +4913,23 @@ class CHIPIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::Identify::IdentifyEffectVariant value); }; +class CHIPIdentifyClusterIdentifyEffectVariantAttributeCallbackSubscriptionBridge + : public CHIPIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge +{ +public: + CHIPIdentifyClusterIdentifyEffectVariantAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge : public CHIPCallbackBridge { @@ -2820,6 +4943,23 @@ class CHIPNullableIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableIdentifyClusterIdentifyEffectVariantAttributeCallbackSubscriptionBridge + : public CHIPNullableIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge +{ +public: + CHIPNullableIdentifyClusterIdentifyEffectVariantAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -2831,6 +4971,23 @@ class CHIPIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::Identify::IdentifyIdentifyType value); }; +class CHIPIdentifyClusterIdentifyIdentifyTypeAttributeCallbackSubscriptionBridge + : public CHIPIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge +{ +public: + CHIPIdentifyClusterIdentifyIdentifyTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -2844,6 +5001,23 @@ class CHIPNullableIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableIdentifyClusterIdentifyIdentifyTypeAttributeCallbackSubscriptionBridge + : public CHIPNullableIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge +{ +public: + CHIPNullableIdentifyClusterIdentifyIdentifyTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge : public CHIPCallbackBridge { @@ -2856,6 +5030,23 @@ class CHIPOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::OnOff::OnOffDelayedAllOffEffectVariant value); }; +class CHIPOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackSubscriptionBridge + : public CHIPOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge +{ +public: + CHIPOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge : public CHIPCallbackBridge { @@ -2870,6 +5061,23 @@ class CHIPNullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBr const chip::app::DataModel::Nullable & value); }; +class CHIPNullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackSubscriptionBridge + : public CHIPNullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge +{ +public: + CHIPNullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge : public CHIPCallbackBridge { @@ -2882,6 +5090,23 @@ class CHIPOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::OnOff::OnOffDyingLightEffectVariant value); }; +class CHIPOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackSubscriptionBridge + : public CHIPOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge +{ +public: + CHIPOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge : public CHIPCallbackBridge { @@ -2895,6 +5120,23 @@ class CHIPNullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridg const chip::app::DataModel::Nullable & value); }; +class CHIPNullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackSubscriptionBridge + : public CHIPNullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge +{ +public: + CHIPNullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPOnOffClusterOnOffEffectIdentifierAttributeCallbackBridge : public CHIPCallbackBridge { @@ -2906,6 +5148,23 @@ class CHIPOnOffClusterOnOffEffectIdentifierAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::OnOff::OnOffEffectIdentifier value); }; +class CHIPOnOffClusterOnOffEffectIdentifierAttributeCallbackSubscriptionBridge + : public CHIPOnOffClusterOnOffEffectIdentifierAttributeCallbackBridge +{ +public: + CHIPOnOffClusterOnOffEffectIdentifierAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPOnOffClusterOnOffEffectIdentifierAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableOnOffClusterOnOffEffectIdentifierAttributeCallbackBridge : public CHIPCallbackBridge { @@ -2919,6 +5178,23 @@ class CHIPNullableOnOffClusterOnOffEffectIdentifierAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableOnOffClusterOnOffEffectIdentifierAttributeCallbackSubscriptionBridge + : public CHIPNullableOnOffClusterOnOffEffectIdentifierAttributeCallbackBridge +{ +public: + CHIPNullableOnOffClusterOnOffEffectIdentifierAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableOnOffClusterOnOffEffectIdentifierAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPLevelControlClusterMoveModeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -2930,6 +5206,23 @@ class CHIPLevelControlClusterMoveModeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::LevelControl::MoveMode value); }; +class CHIPLevelControlClusterMoveModeAttributeCallbackSubscriptionBridge + : public CHIPLevelControlClusterMoveModeAttributeCallbackBridge +{ +public: + CHIPLevelControlClusterMoveModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPLevelControlClusterMoveModeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableLevelControlClusterMoveModeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -2942,6 +5235,23 @@ class CHIPNullableLevelControlClusterMoveModeAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableLevelControlClusterMoveModeAttributeCallbackSubscriptionBridge + : public CHIPNullableLevelControlClusterMoveModeAttributeCallbackBridge +{ +public: + CHIPNullableLevelControlClusterMoveModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableLevelControlClusterMoveModeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPLevelControlClusterStepModeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -2953,6 +5263,23 @@ class CHIPLevelControlClusterStepModeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::LevelControl::StepMode value); }; +class CHIPLevelControlClusterStepModeAttributeCallbackSubscriptionBridge + : public CHIPLevelControlClusterStepModeAttributeCallbackBridge +{ +public: + CHIPLevelControlClusterStepModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPLevelControlClusterStepModeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableLevelControlClusterStepModeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -2965,6 +5292,23 @@ class CHIPNullableLevelControlClusterStepModeAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableLevelControlClusterStepModeAttributeCallbackSubscriptionBridge + : public CHIPNullableLevelControlClusterStepModeAttributeCallbackBridge +{ +public: + CHIPNullableLevelControlClusterStepModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableLevelControlClusterStepModeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPApplianceControlClusterApplianceStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -2977,6 +5321,23 @@ class CHIPApplianceControlClusterApplianceStatusAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::ApplianceControl::ApplianceStatus value); }; +class CHIPApplianceControlClusterApplianceStatusAttributeCallbackSubscriptionBridge + : public CHIPApplianceControlClusterApplianceStatusAttributeCallbackBridge +{ +public: + CHIPApplianceControlClusterApplianceStatusAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPApplianceControlClusterApplianceStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableApplianceControlClusterApplianceStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -2990,6 +5351,23 @@ class CHIPNullableApplianceControlClusterApplianceStatusAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableApplianceControlClusterApplianceStatusAttributeCallbackSubscriptionBridge + : public CHIPNullableApplianceControlClusterApplianceStatusAttributeCallbackBridge +{ +public: + CHIPNullableApplianceControlClusterApplianceStatusAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableApplianceControlClusterApplianceStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPApplianceControlClusterCommandIdentificationAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3002,6 +5380,23 @@ class CHIPApplianceControlClusterCommandIdentificationAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::ApplianceControl::CommandIdentification value); }; +class CHIPApplianceControlClusterCommandIdentificationAttributeCallbackSubscriptionBridge + : public CHIPApplianceControlClusterCommandIdentificationAttributeCallbackBridge +{ +public: + CHIPApplianceControlClusterCommandIdentificationAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPApplianceControlClusterCommandIdentificationAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableApplianceControlClusterCommandIdentificationAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3017,6 +5412,23 @@ class CHIPNullableApplianceControlClusterCommandIdentificationAttributeCallbackB const chip::app::DataModel::Nullable & value); }; +class CHIPNullableApplianceControlClusterCommandIdentificationAttributeCallbackSubscriptionBridge + : public CHIPNullableApplianceControlClusterCommandIdentificationAttributeCallbackBridge +{ +public: + CHIPNullableApplianceControlClusterCommandIdentificationAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableApplianceControlClusterCommandIdentificationAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPApplianceControlClusterWarningEventAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3028,6 +5440,23 @@ class CHIPApplianceControlClusterWarningEventAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::ApplianceControl::WarningEvent value); }; +class CHIPApplianceControlClusterWarningEventAttributeCallbackSubscriptionBridge + : public CHIPApplianceControlClusterWarningEventAttributeCallbackBridge +{ +public: + CHIPApplianceControlClusterWarningEventAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPApplianceControlClusterWarningEventAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableApplianceControlClusterWarningEventAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3041,6 +5470,23 @@ class CHIPNullableApplianceControlClusterWarningEventAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableApplianceControlClusterWarningEventAttributeCallbackSubscriptionBridge + : public CHIPNullableApplianceControlClusterWarningEventAttributeCallbackBridge +{ +public: + CHIPNullableApplianceControlClusterWarningEventAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableApplianceControlClusterWarningEventAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPAccessControlClusterAuthModeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3052,6 +5498,23 @@ class CHIPAccessControlClusterAuthModeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::AccessControl::AuthMode value); }; +class CHIPAccessControlClusterAuthModeAttributeCallbackSubscriptionBridge + : public CHIPAccessControlClusterAuthModeAttributeCallbackBridge +{ +public: + CHIPAccessControlClusterAuthModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPAccessControlClusterAuthModeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableAccessControlClusterAuthModeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3064,6 +5527,23 @@ class CHIPNullableAccessControlClusterAuthModeAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableAccessControlClusterAuthModeAttributeCallbackSubscriptionBridge + : public CHIPNullableAccessControlClusterAuthModeAttributeCallbackBridge +{ +public: + CHIPNullableAccessControlClusterAuthModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableAccessControlClusterAuthModeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPAccessControlClusterPrivilegeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3075,6 +5555,23 @@ class CHIPAccessControlClusterPrivilegeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::AccessControl::Privilege value); }; +class CHIPAccessControlClusterPrivilegeAttributeCallbackSubscriptionBridge + : public CHIPAccessControlClusterPrivilegeAttributeCallbackBridge +{ +public: + CHIPAccessControlClusterPrivilegeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPAccessControlClusterPrivilegeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableAccessControlClusterPrivilegeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3088,6 +5585,23 @@ class CHIPNullableAccessControlClusterPrivilegeAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableAccessControlClusterPrivilegeAttributeCallbackSubscriptionBridge + : public CHIPNullableAccessControlClusterPrivilegeAttributeCallbackBridge +{ +public: + CHIPNullableAccessControlClusterPrivilegeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableAccessControlClusterPrivilegeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPBridgedActionsClusterActionErrorEnumAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3099,6 +5613,23 @@ class CHIPBridgedActionsClusterActionErrorEnumAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::BridgedActions::ActionErrorEnum value); }; +class CHIPBridgedActionsClusterActionErrorEnumAttributeCallbackSubscriptionBridge + : public CHIPBridgedActionsClusterActionErrorEnumAttributeCallbackBridge +{ +public: + CHIPBridgedActionsClusterActionErrorEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPBridgedActionsClusterActionErrorEnumAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableBridgedActionsClusterActionErrorEnumAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3112,6 +5643,23 @@ class CHIPNullableBridgedActionsClusterActionErrorEnumAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableBridgedActionsClusterActionErrorEnumAttributeCallbackSubscriptionBridge + : public CHIPNullableBridgedActionsClusterActionErrorEnumAttributeCallbackBridge +{ +public: + CHIPNullableBridgedActionsClusterActionErrorEnumAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableBridgedActionsClusterActionErrorEnumAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPBridgedActionsClusterActionStateEnumAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3123,6 +5671,23 @@ class CHIPBridgedActionsClusterActionStateEnumAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::BridgedActions::ActionStateEnum value); }; +class CHIPBridgedActionsClusterActionStateEnumAttributeCallbackSubscriptionBridge + : public CHIPBridgedActionsClusterActionStateEnumAttributeCallbackBridge +{ +public: + CHIPBridgedActionsClusterActionStateEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPBridgedActionsClusterActionStateEnumAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableBridgedActionsClusterActionStateEnumAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3136,6 +5701,23 @@ class CHIPNullableBridgedActionsClusterActionStateEnumAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableBridgedActionsClusterActionStateEnumAttributeCallbackSubscriptionBridge + : public CHIPNullableBridgedActionsClusterActionStateEnumAttributeCallbackBridge +{ +public: + CHIPNullableBridgedActionsClusterActionStateEnumAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableBridgedActionsClusterActionStateEnumAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPBridgedActionsClusterActionTypeEnumAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3147,6 +5729,23 @@ class CHIPBridgedActionsClusterActionTypeEnumAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::BridgedActions::ActionTypeEnum value); }; +class CHIPBridgedActionsClusterActionTypeEnumAttributeCallbackSubscriptionBridge + : public CHIPBridgedActionsClusterActionTypeEnumAttributeCallbackBridge +{ +public: + CHIPBridgedActionsClusterActionTypeEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPBridgedActionsClusterActionTypeEnumAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableBridgedActionsClusterActionTypeEnumAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3160,6 +5759,23 @@ class CHIPNullableBridgedActionsClusterActionTypeEnumAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableBridgedActionsClusterActionTypeEnumAttributeCallbackSubscriptionBridge + : public CHIPNullableBridgedActionsClusterActionTypeEnumAttributeCallbackBridge +{ +public: + CHIPNullableBridgedActionsClusterActionTypeEnumAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableBridgedActionsClusterActionTypeEnumAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPBridgedActionsClusterEndpointListTypeEnumAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3172,6 +5788,23 @@ class CHIPBridgedActionsClusterEndpointListTypeEnumAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::BridgedActions::EndpointListTypeEnum value); }; +class CHIPBridgedActionsClusterEndpointListTypeEnumAttributeCallbackSubscriptionBridge + : public CHIPBridgedActionsClusterEndpointListTypeEnumAttributeCallbackBridge +{ +public: + CHIPBridgedActionsClusterEndpointListTypeEnumAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPBridgedActionsClusterEndpointListTypeEnumAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableBridgedActionsClusterEndpointListTypeEnumAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3186,6 +5819,23 @@ class CHIPNullableBridgedActionsClusterEndpointListTypeEnumAttributeCallbackBrid const chip::app::DataModel::Nullable & value); }; +class CHIPNullableBridgedActionsClusterEndpointListTypeEnumAttributeCallbackSubscriptionBridge + : public CHIPNullableBridgedActionsClusterEndpointListTypeEnumAttributeCallbackBridge +{ +public: + CHIPNullableBridgedActionsClusterEndpointListTypeEnumAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableBridgedActionsClusterEndpointListTypeEnumAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPOtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3199,6 +5849,23 @@ class CHIPOtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackB static void OnSuccessFn(void * context, chip::app::Clusters::OtaSoftwareUpdateProvider::OTAApplyUpdateAction value); }; +class CHIPOtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackSubscriptionBridge + : public CHIPOtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge +{ +public: + CHIPOtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPOtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableOtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3215,6 +5882,23 @@ class CHIPNullableOtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeC const chip::app::DataModel::Nullable & value); }; +class CHIPNullableOtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackSubscriptionBridge + : public CHIPNullableOtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge +{ +public: + CHIPNullableOtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableOtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPOtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3227,6 +5911,23 @@ class CHIPOtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBr static void OnSuccessFn(void * context, chip::app::Clusters::OtaSoftwareUpdateProvider::OTADownloadProtocol value); }; +class CHIPOtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackSubscriptionBridge + : public CHIPOtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge +{ +public: + CHIPOtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPOtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableOtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3243,6 +5944,23 @@ class CHIPNullableOtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCa const chip::app::DataModel::Nullable & value); }; +class CHIPNullableOtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackSubscriptionBridge + : public CHIPNullableOtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge +{ +public: + CHIPNullableOtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableOtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPOtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3255,6 +5973,23 @@ class CHIPOtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::OtaSoftwareUpdateProvider::OTAQueryStatus value); }; +class CHIPOtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackSubscriptionBridge + : public CHIPOtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge +{ +public: + CHIPOtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPOtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableOtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3271,6 +6006,23 @@ class CHIPNullableOtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbac const chip::app::DataModel::Nullable & value); }; +class CHIPNullableOtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackSubscriptionBridge + : public CHIPNullableOtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge +{ +public: + CHIPNullableOtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableOtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPOtaSoftwareUpdateRequestorClusterChangeReasonEnumAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3283,6 +6035,23 @@ class CHIPOtaSoftwareUpdateRequestorClusterChangeReasonEnumAttributeCallbackBrid static void OnSuccessFn(void * context, chip::app::Clusters::OtaSoftwareUpdateRequestor::ChangeReasonEnum value); }; +class CHIPOtaSoftwareUpdateRequestorClusterChangeReasonEnumAttributeCallbackSubscriptionBridge + : public CHIPOtaSoftwareUpdateRequestorClusterChangeReasonEnumAttributeCallbackBridge +{ +public: + CHIPOtaSoftwareUpdateRequestorClusterChangeReasonEnumAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPOtaSoftwareUpdateRequestorClusterChangeReasonEnumAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableOtaSoftwareUpdateRequestorClusterChangeReasonEnumAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3299,6 +6068,23 @@ class CHIPNullableOtaSoftwareUpdateRequestorClusterChangeReasonEnumAttributeCall const chip::app::DataModel::Nullable & value); }; +class CHIPNullableOtaSoftwareUpdateRequestorClusterChangeReasonEnumAttributeCallbackSubscriptionBridge + : public CHIPNullableOtaSoftwareUpdateRequestorClusterChangeReasonEnumAttributeCallbackBridge +{ +public: + CHIPNullableOtaSoftwareUpdateRequestorClusterChangeReasonEnumAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableOtaSoftwareUpdateRequestorClusterChangeReasonEnumAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPOtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3313,6 +6099,23 @@ class CHIPOtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbac static void OnSuccessFn(void * context, chip::app::Clusters::OtaSoftwareUpdateRequestor::OTAAnnouncementReason value); }; +class CHIPOtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackSubscriptionBridge + : public CHIPOtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge +{ +public: + CHIPOtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPOtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableOtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3329,6 +6132,23 @@ class CHIPNullableOtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttribut const chip::app::DataModel::Nullable & value); }; +class CHIPNullableOtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackSubscriptionBridge + : public CHIPNullableOtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge +{ +public: + CHIPNullableOtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableOtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPOtaSoftwareUpdateRequestorClusterUpdateStateEnumAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3341,6 +6161,23 @@ class CHIPOtaSoftwareUpdateRequestorClusterUpdateStateEnumAttributeCallbackBridg static void OnSuccessFn(void * context, chip::app::Clusters::OtaSoftwareUpdateRequestor::UpdateStateEnum value); }; +class CHIPOtaSoftwareUpdateRequestorClusterUpdateStateEnumAttributeCallbackSubscriptionBridge + : public CHIPOtaSoftwareUpdateRequestorClusterUpdateStateEnumAttributeCallbackBridge +{ +public: + CHIPOtaSoftwareUpdateRequestorClusterUpdateStateEnumAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPOtaSoftwareUpdateRequestorClusterUpdateStateEnumAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableOtaSoftwareUpdateRequestorClusterUpdateStateEnumAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3357,6 +6194,23 @@ class CHIPNullableOtaSoftwareUpdateRequestorClusterUpdateStateEnumAttributeCallb const chip::app::DataModel::Nullable & value); }; +class CHIPNullableOtaSoftwareUpdateRequestorClusterUpdateStateEnumAttributeCallbackSubscriptionBridge + : public CHIPNullableOtaSoftwareUpdateRequestorClusterUpdateStateEnumAttributeCallbackBridge +{ +public: + CHIPNullableOtaSoftwareUpdateRequestorClusterUpdateStateEnumAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableOtaSoftwareUpdateRequestorClusterUpdateStateEnumAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPGeneralCommissioningClusterGeneralCommissioningErrorAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3370,6 +6224,23 @@ class CHIPGeneralCommissioningClusterGeneralCommissioningErrorAttributeCallbackB static void OnSuccessFn(void * context, chip::app::Clusters::GeneralCommissioning::GeneralCommissioningError value); }; +class CHIPGeneralCommissioningClusterGeneralCommissioningErrorAttributeCallbackSubscriptionBridge + : public CHIPGeneralCommissioningClusterGeneralCommissioningErrorAttributeCallbackBridge +{ +public: + CHIPGeneralCommissioningClusterGeneralCommissioningErrorAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPGeneralCommissioningClusterGeneralCommissioningErrorAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableGeneralCommissioningClusterGeneralCommissioningErrorAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3386,6 +6257,23 @@ class CHIPNullableGeneralCommissioningClusterGeneralCommissioningErrorAttributeC const chip::app::DataModel::Nullable & value); }; +class CHIPNullableGeneralCommissioningClusterGeneralCommissioningErrorAttributeCallbackSubscriptionBridge + : public CHIPNullableGeneralCommissioningClusterGeneralCommissioningErrorAttributeCallbackBridge +{ +public: + CHIPNullableGeneralCommissioningClusterGeneralCommissioningErrorAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableGeneralCommissioningClusterGeneralCommissioningErrorAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3398,6 +6286,23 @@ class CHIPGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBrid static void OnSuccessFn(void * context, chip::app::Clusters::GeneralCommissioning::RegulatoryLocationType value); }; +class CHIPGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge + : public CHIPGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge +{ +public: + CHIPGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3414,6 +6319,23 @@ class CHIPNullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCall const chip::app::DataModel::Nullable & value); }; +class CHIPNullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge + : public CHIPNullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge +{ +public: + CHIPNullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNetworkCommissioningClusterNetworkCommissioningErrorAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3427,6 +6349,23 @@ class CHIPNetworkCommissioningClusterNetworkCommissioningErrorAttributeCallbackB static void OnSuccessFn(void * context, chip::app::Clusters::NetworkCommissioning::NetworkCommissioningError value); }; +class CHIPNetworkCommissioningClusterNetworkCommissioningErrorAttributeCallbackSubscriptionBridge + : public CHIPNetworkCommissioningClusterNetworkCommissioningErrorAttributeCallbackBridge +{ +public: + CHIPNetworkCommissioningClusterNetworkCommissioningErrorAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNetworkCommissioningClusterNetworkCommissioningErrorAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableNetworkCommissioningClusterNetworkCommissioningErrorAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3443,6 +6382,23 @@ class CHIPNullableNetworkCommissioningClusterNetworkCommissioningErrorAttributeC const chip::app::DataModel::Nullable & value); }; +class CHIPNullableNetworkCommissioningClusterNetworkCommissioningErrorAttributeCallbackSubscriptionBridge + : public CHIPNullableNetworkCommissioningClusterNetworkCommissioningErrorAttributeCallbackBridge +{ +public: + CHIPNullableNetworkCommissioningClusterNetworkCommissioningErrorAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableNetworkCommissioningClusterNetworkCommissioningErrorAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPDiagnosticLogsClusterLogsIntentAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3454,6 +6410,23 @@ class CHIPDiagnosticLogsClusterLogsIntentAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::DiagnosticLogs::LogsIntent value); }; +class CHIPDiagnosticLogsClusterLogsIntentAttributeCallbackSubscriptionBridge + : public CHIPDiagnosticLogsClusterLogsIntentAttributeCallbackBridge +{ +public: + CHIPDiagnosticLogsClusterLogsIntentAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPDiagnosticLogsClusterLogsIntentAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableDiagnosticLogsClusterLogsIntentAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3467,6 +6440,23 @@ class CHIPNullableDiagnosticLogsClusterLogsIntentAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableDiagnosticLogsClusterLogsIntentAttributeCallbackSubscriptionBridge + : public CHIPNullableDiagnosticLogsClusterLogsIntentAttributeCallbackBridge +{ +public: + CHIPNullableDiagnosticLogsClusterLogsIntentAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableDiagnosticLogsClusterLogsIntentAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPDiagnosticLogsClusterLogsStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3478,6 +6468,23 @@ class CHIPDiagnosticLogsClusterLogsStatusAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::DiagnosticLogs::LogsStatus value); }; +class CHIPDiagnosticLogsClusterLogsStatusAttributeCallbackSubscriptionBridge + : public CHIPDiagnosticLogsClusterLogsStatusAttributeCallbackBridge +{ +public: + CHIPDiagnosticLogsClusterLogsStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPDiagnosticLogsClusterLogsStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableDiagnosticLogsClusterLogsStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3491,6 +6498,23 @@ class CHIPNullableDiagnosticLogsClusterLogsStatusAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableDiagnosticLogsClusterLogsStatusAttributeCallbackSubscriptionBridge + : public CHIPNullableDiagnosticLogsClusterLogsStatusAttributeCallbackBridge +{ +public: + CHIPNullableDiagnosticLogsClusterLogsStatusAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableDiagnosticLogsClusterLogsStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3503,6 +6527,23 @@ class CHIPDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::DiagnosticLogs::LogsTransferProtocol value); }; +class CHIPDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackSubscriptionBridge + : public CHIPDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge +{ +public: + CHIPDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3517,6 +6558,23 @@ class CHIPNullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBrid const chip::app::DataModel::Nullable & value); }; +class CHIPNullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackSubscriptionBridge + : public CHIPNullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge +{ +public: + CHIPNullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3529,6 +6587,23 @@ class CHIPGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::GeneralDiagnostics::BootReasonType value); }; +class CHIPGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackSubscriptionBridge + : public CHIPGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge +{ +public: + CHIPGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3542,6 +6617,23 @@ class CHIPNullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackSubscriptionBridge + : public CHIPNullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge +{ +public: + CHIPNullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3554,6 +6646,23 @@ class CHIPGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::GeneralDiagnostics::HardwareFaultType value); }; +class CHIPGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackSubscriptionBridge + : public CHIPGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge +{ +public: + CHIPGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3568,6 +6677,23 @@ class CHIPNullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBri const chip::app::DataModel::Nullable & value); }; +class CHIPNullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackSubscriptionBridge + : public CHIPNullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge +{ +public: + CHIPNullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3580,6 +6706,23 @@ class CHIPGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::GeneralDiagnostics::InterfaceType value); }; +class CHIPGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackSubscriptionBridge + : public CHIPGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge +{ +public: + CHIPGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3593,6 +6736,23 @@ class CHIPNullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackSubscriptionBridge + : public CHIPNullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge +{ +public: + CHIPNullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3605,6 +6765,23 @@ class CHIPGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::GeneralDiagnostics::NetworkFaultType value); }; +class CHIPGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackSubscriptionBridge + : public CHIPGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge +{ +public: + CHIPGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3619,6 +6796,23 @@ class CHIPNullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBrid const chip::app::DataModel::Nullable & value); }; +class CHIPNullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackSubscriptionBridge + : public CHIPNullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge +{ +public: + CHIPNullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3631,6 +6825,23 @@ class CHIPGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::GeneralDiagnostics::RadioFaultType value); }; +class CHIPGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackSubscriptionBridge + : public CHIPGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge +{ +public: + CHIPGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3644,6 +6855,23 @@ class CHIPNullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackSubscriptionBridge + : public CHIPNullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge +{ +public: + CHIPNullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3656,6 +6884,23 @@ class CHIPThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::ThreadNetworkDiagnostics::NetworkFault value); }; +class CHIPThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackSubscriptionBridge + : public CHIPThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge +{ +public: + CHIPThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3670,6 +6915,23 @@ class CHIPNullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBr const chip::app::DataModel::Nullable & value); }; +class CHIPNullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackSubscriptionBridge + : public CHIPNullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge +{ +public: + CHIPNullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3682,6 +6944,23 @@ class CHIPThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::ThreadNetworkDiagnostics::RoutingRole value); }; +class CHIPThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackSubscriptionBridge + : public CHIPThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge +{ +public: + CHIPThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3696,6 +6975,23 @@ class CHIPNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBri const chip::app::DataModel::Nullable & value); }; +class CHIPNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackSubscriptionBridge + : public CHIPNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge +{ +public: + CHIPNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3710,6 +7006,23 @@ class CHIPThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallback static void OnSuccessFn(void * context, chip::app::Clusters::ThreadNetworkDiagnostics::ThreadConnectionStatus value); }; +class CHIPThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackSubscriptionBridge + : public CHIPThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge +{ +public: + CHIPThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3726,6 +7039,23 @@ class CHIPNullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttribute const chip::app::DataModel::Nullable & value); }; +class CHIPNullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackSubscriptionBridge + : public CHIPNullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge +{ +public: + CHIPNullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3739,6 +7069,23 @@ class CHIPWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackB static void OnSuccessFn(void * context, chip::app::Clusters::WiFiNetworkDiagnostics::AssociationFailureCause value); }; +class CHIPWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackSubscriptionBridge + : public CHIPWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge +{ +public: + CHIPWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3755,6 +7102,23 @@ class CHIPNullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeC const chip::app::DataModel::Nullable & value); }; +class CHIPNullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackSubscriptionBridge + : public CHIPNullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge +{ +public: + CHIPNullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3767,6 +7131,23 @@ class CHIPWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::WiFiNetworkDiagnostics::SecurityType value); }; +class CHIPWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackSubscriptionBridge + : public CHIPWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge +{ +public: + CHIPWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3781,6 +7162,23 @@ class CHIPNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBrid const chip::app::DataModel::Nullable & value); }; +class CHIPNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackSubscriptionBridge + : public CHIPNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge +{ +public: + CHIPNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3793,6 +7191,23 @@ class CHIPWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBrid static void OnSuccessFn(void * context, chip::app::Clusters::WiFiNetworkDiagnostics::WiFiConnectionStatus value); }; +class CHIPWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackSubscriptionBridge + : public CHIPWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge +{ +public: + CHIPWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3809,6 +7224,23 @@ class CHIPNullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCall const chip::app::DataModel::Nullable & value); }; +class CHIPNullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackSubscriptionBridge + : public CHIPNullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge +{ +public: + CHIPNullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3821,6 +7253,23 @@ class CHIPWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::WiFiNetworkDiagnostics::WiFiVersionType value); }; +class CHIPWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackSubscriptionBridge + : public CHIPWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge +{ +public: + CHIPWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3836,6 +7285,23 @@ class CHIPNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackB const chip::app::DataModel::Nullable & value); }; +class CHIPNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackSubscriptionBridge + : public CHIPNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge +{ +public: + CHIPNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3848,6 +7314,23 @@ class CHIPEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::EthernetNetworkDiagnostics::PHYRateType value); }; +class CHIPEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackSubscriptionBridge + : public CHIPEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge +{ +public: + CHIPEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3863,6 +7346,23 @@ class CHIPNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackB const chip::app::DataModel::Nullable & value); }; +class CHIPNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackSubscriptionBridge + : public CHIPNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge +{ +public: + CHIPNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3877,6 +7377,23 @@ class CHIPAdministratorCommissioningClusterCommissioningWindowStatusAttributeCal static void OnSuccessFn(void * context, chip::app::Clusters::AdministratorCommissioning::CommissioningWindowStatus value); }; +class CHIPAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackSubscriptionBridge + : public CHIPAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge +{ +public: + CHIPAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3893,6 +7410,23 @@ class CHIPNullableAdministratorCommissioningClusterCommissioningWindowStatusAttr const chip::app::DataModel::Nullable & value); }; +class CHIPNullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackSubscriptionBridge + : public CHIPNullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge +{ +public: + CHIPNullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3905,6 +7439,23 @@ class CHIPAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::AdministratorCommissioning::StatusCode value); }; +class CHIPAdministratorCommissioningClusterStatusCodeAttributeCallbackSubscriptionBridge + : public CHIPAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge +{ +public: + CHIPAdministratorCommissioningClusterStatusCodeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3919,6 +7470,23 @@ class CHIPNullableAdministratorCommissioningClusterStatusCodeAttributeCallbackBr const chip::app::DataModel::Nullable & value); }; +class CHIPNullableAdministratorCommissioningClusterStatusCodeAttributeCallbackSubscriptionBridge + : public CHIPNullableAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge +{ +public: + CHIPNullableAdministratorCommissioningClusterStatusCodeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPOperationalCredentialsClusterNodeOperationalCertStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3933,6 +7501,23 @@ class CHIPOperationalCredentialsClusterNodeOperationalCertStatusAttributeCallbac static void OnSuccessFn(void * context, chip::app::Clusters::OperationalCredentials::NodeOperationalCertStatus value); }; +class CHIPOperationalCredentialsClusterNodeOperationalCertStatusAttributeCallbackSubscriptionBridge + : public CHIPOperationalCredentialsClusterNodeOperationalCertStatusAttributeCallbackBridge +{ +public: + CHIPOperationalCredentialsClusterNodeOperationalCertStatusAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPOperationalCredentialsClusterNodeOperationalCertStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableOperationalCredentialsClusterNodeOperationalCertStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3949,6 +7534,23 @@ class CHIPNullableOperationalCredentialsClusterNodeOperationalCertStatusAttribut const chip::app::DataModel::Nullable & value); }; +class CHIPNullableOperationalCredentialsClusterNodeOperationalCertStatusAttributeCallbackSubscriptionBridge + : public CHIPNullableOperationalCredentialsClusterNodeOperationalCertStatusAttributeCallbackBridge +{ +public: + CHIPNullableOperationalCredentialsClusterNodeOperationalCertStatusAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableOperationalCredentialsClusterNodeOperationalCertStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3961,6 +7563,23 @@ class CHIPGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::GroupKeyManagement::GroupKeySecurityPolicy value); }; +class CHIPGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackSubscriptionBridge + : public CHIPGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge +{ +public: + CHIPGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3977,6 +7596,23 @@ class CHIPNullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallba const chip::app::DataModel::Nullable & value); }; +class CHIPNullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackSubscriptionBridge + : public CHIPNullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge +{ +public: + CHIPNullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPDoorLockClusterDlAlarmCodeAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -3987,6 +7623,23 @@ class CHIPDoorLockClusterDlAlarmCodeAttributeCallbackBridge : public CHIPCallbac static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlAlarmCode value); }; +class CHIPDoorLockClusterDlAlarmCodeAttributeCallbackSubscriptionBridge + : public CHIPDoorLockClusterDlAlarmCodeAttributeCallbackBridge +{ +public: + CHIPDoorLockClusterDlAlarmCodeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPDoorLockClusterDlAlarmCodeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableDoorLockClusterDlAlarmCodeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -3995,8 +7648,25 @@ class CHIPNullableDoorLockClusterDlAlarmCodeAttributeCallbackBridge CHIPActionBlock action, bool keepAlive = false) : CHIPCallbackBridge(queue, handler, action, OnSuccessFn, keepAlive){}; - static void OnSuccessFn(void * context, - const chip::app::DataModel::Nullable & value); + static void OnSuccessFn(void * context, + const chip::app::DataModel::Nullable & value); +}; + +class CHIPNullableDoorLockClusterDlAlarmCodeAttributeCallbackSubscriptionBridge + : public CHIPNullableDoorLockClusterDlAlarmCodeAttributeCallbackBridge +{ +public: + CHIPNullableDoorLockClusterDlAlarmCodeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableDoorLockClusterDlAlarmCodeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; }; class CHIPDoorLockClusterDlCredentialRuleAttributeCallbackBridge @@ -4010,6 +7680,23 @@ class CHIPDoorLockClusterDlCredentialRuleAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlCredentialRule value); }; +class CHIPDoorLockClusterDlCredentialRuleAttributeCallbackSubscriptionBridge + : public CHIPDoorLockClusterDlCredentialRuleAttributeCallbackBridge +{ +public: + CHIPDoorLockClusterDlCredentialRuleAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPDoorLockClusterDlCredentialRuleAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableDoorLockClusterDlCredentialRuleAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4023,6 +7710,23 @@ class CHIPNullableDoorLockClusterDlCredentialRuleAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableDoorLockClusterDlCredentialRuleAttributeCallbackSubscriptionBridge + : public CHIPNullableDoorLockClusterDlCredentialRuleAttributeCallbackBridge +{ +public: + CHIPNullableDoorLockClusterDlCredentialRuleAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableDoorLockClusterDlCredentialRuleAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPDoorLockClusterDlCredentialTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4034,6 +7738,23 @@ class CHIPDoorLockClusterDlCredentialTypeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlCredentialType value); }; +class CHIPDoorLockClusterDlCredentialTypeAttributeCallbackSubscriptionBridge + : public CHIPDoorLockClusterDlCredentialTypeAttributeCallbackBridge +{ +public: + CHIPDoorLockClusterDlCredentialTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPDoorLockClusterDlCredentialTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableDoorLockClusterDlCredentialTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4047,6 +7768,23 @@ class CHIPNullableDoorLockClusterDlCredentialTypeAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableDoorLockClusterDlCredentialTypeAttributeCallbackSubscriptionBridge + : public CHIPNullableDoorLockClusterDlCredentialTypeAttributeCallbackBridge +{ +public: + CHIPNullableDoorLockClusterDlCredentialTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableDoorLockClusterDlCredentialTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPDoorLockClusterDlDataOperationTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4058,6 +7796,23 @@ class CHIPDoorLockClusterDlDataOperationTypeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlDataOperationType value); }; +class CHIPDoorLockClusterDlDataOperationTypeAttributeCallbackSubscriptionBridge + : public CHIPDoorLockClusterDlDataOperationTypeAttributeCallbackBridge +{ +public: + CHIPDoorLockClusterDlDataOperationTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPDoorLockClusterDlDataOperationTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableDoorLockClusterDlDataOperationTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4071,6 +7826,23 @@ class CHIPNullableDoorLockClusterDlDataOperationTypeAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableDoorLockClusterDlDataOperationTypeAttributeCallbackSubscriptionBridge + : public CHIPNullableDoorLockClusterDlDataOperationTypeAttributeCallbackBridge +{ +public: + CHIPNullableDoorLockClusterDlDataOperationTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableDoorLockClusterDlDataOperationTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPDoorLockClusterDlDoorLockStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4082,6 +7854,23 @@ class CHIPDoorLockClusterDlDoorLockStatusAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlDoorLockStatus value); }; +class CHIPDoorLockClusterDlDoorLockStatusAttributeCallbackSubscriptionBridge + : public CHIPDoorLockClusterDlDoorLockStatusAttributeCallbackBridge +{ +public: + CHIPDoorLockClusterDlDoorLockStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPDoorLockClusterDlDoorLockStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableDoorLockClusterDlDoorLockStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4095,6 +7884,23 @@ class CHIPNullableDoorLockClusterDlDoorLockStatusAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableDoorLockClusterDlDoorLockStatusAttributeCallbackSubscriptionBridge + : public CHIPNullableDoorLockClusterDlDoorLockStatusAttributeCallbackBridge +{ +public: + CHIPNullableDoorLockClusterDlDoorLockStatusAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableDoorLockClusterDlDoorLockStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPDoorLockClusterDlDoorStateAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -4105,6 +7911,23 @@ class CHIPDoorLockClusterDlDoorStateAttributeCallbackBridge : public CHIPCallbac static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlDoorState value); }; +class CHIPDoorLockClusterDlDoorStateAttributeCallbackSubscriptionBridge + : public CHIPDoorLockClusterDlDoorStateAttributeCallbackBridge +{ +public: + CHIPDoorLockClusterDlDoorStateAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPDoorLockClusterDlDoorStateAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableDoorLockClusterDlDoorStateAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4117,6 +7940,23 @@ class CHIPNullableDoorLockClusterDlDoorStateAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableDoorLockClusterDlDoorStateAttributeCallbackSubscriptionBridge + : public CHIPNullableDoorLockClusterDlDoorStateAttributeCallbackBridge +{ +public: + CHIPNullableDoorLockClusterDlDoorStateAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableDoorLockClusterDlDoorStateAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPDoorLockClusterDlLockDataTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4128,6 +7968,23 @@ class CHIPDoorLockClusterDlLockDataTypeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlLockDataType value); }; +class CHIPDoorLockClusterDlLockDataTypeAttributeCallbackSubscriptionBridge + : public CHIPDoorLockClusterDlLockDataTypeAttributeCallbackBridge +{ +public: + CHIPDoorLockClusterDlLockDataTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPDoorLockClusterDlLockDataTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableDoorLockClusterDlLockDataTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4141,6 +7998,23 @@ class CHIPNullableDoorLockClusterDlLockDataTypeAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableDoorLockClusterDlLockDataTypeAttributeCallbackSubscriptionBridge + : public CHIPNullableDoorLockClusterDlLockDataTypeAttributeCallbackBridge +{ +public: + CHIPNullableDoorLockClusterDlLockDataTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableDoorLockClusterDlLockDataTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPDoorLockClusterDlLockOperationTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4152,6 +8026,23 @@ class CHIPDoorLockClusterDlLockOperationTypeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlLockOperationType value); }; +class CHIPDoorLockClusterDlLockOperationTypeAttributeCallbackSubscriptionBridge + : public CHIPDoorLockClusterDlLockOperationTypeAttributeCallbackBridge +{ +public: + CHIPDoorLockClusterDlLockOperationTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPDoorLockClusterDlLockOperationTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableDoorLockClusterDlLockOperationTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4165,6 +8056,23 @@ class CHIPNullableDoorLockClusterDlLockOperationTypeAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableDoorLockClusterDlLockOperationTypeAttributeCallbackSubscriptionBridge + : public CHIPNullableDoorLockClusterDlLockOperationTypeAttributeCallbackBridge +{ +public: + CHIPNullableDoorLockClusterDlLockOperationTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableDoorLockClusterDlLockOperationTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPDoorLockClusterDlLockStateAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -4175,6 +8083,23 @@ class CHIPDoorLockClusterDlLockStateAttributeCallbackBridge : public CHIPCallbac static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlLockState value); }; +class CHIPDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge + : public CHIPDoorLockClusterDlLockStateAttributeCallbackBridge +{ +public: + CHIPDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPDoorLockClusterDlLockStateAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableDoorLockClusterDlLockStateAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4187,6 +8112,23 @@ class CHIPNullableDoorLockClusterDlLockStateAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge + : public CHIPNullableDoorLockClusterDlLockStateAttributeCallbackBridge +{ +public: + CHIPNullableDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableDoorLockClusterDlLockStateAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPDoorLockClusterDlLockTypeAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -4197,6 +8139,22 @@ class CHIPDoorLockClusterDlLockTypeAttributeCallbackBridge : public CHIPCallback static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlLockType value); }; +class CHIPDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge : public CHIPDoorLockClusterDlLockTypeAttributeCallbackBridge +{ +public: + CHIPDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPDoorLockClusterDlLockTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableDoorLockClusterDlLockTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4209,6 +8167,23 @@ class CHIPNullableDoorLockClusterDlLockTypeAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge + : public CHIPNullableDoorLockClusterDlLockTypeAttributeCallbackBridge +{ +public: + CHIPNullableDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableDoorLockClusterDlLockTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPDoorLockClusterDlOperatingModeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4220,6 +8195,23 @@ class CHIPDoorLockClusterDlOperatingModeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlOperatingMode value); }; +class CHIPDoorLockClusterDlOperatingModeAttributeCallbackSubscriptionBridge + : public CHIPDoorLockClusterDlOperatingModeAttributeCallbackBridge +{ +public: + CHIPDoorLockClusterDlOperatingModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPDoorLockClusterDlOperatingModeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableDoorLockClusterDlOperatingModeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4233,6 +8225,23 @@ class CHIPNullableDoorLockClusterDlOperatingModeAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableDoorLockClusterDlOperatingModeAttributeCallbackSubscriptionBridge + : public CHIPNullableDoorLockClusterDlOperatingModeAttributeCallbackBridge +{ +public: + CHIPNullableDoorLockClusterDlOperatingModeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableDoorLockClusterDlOperatingModeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPDoorLockClusterDlOperationErrorAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4244,6 +8253,23 @@ class CHIPDoorLockClusterDlOperationErrorAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlOperationError value); }; +class CHIPDoorLockClusterDlOperationErrorAttributeCallbackSubscriptionBridge + : public CHIPDoorLockClusterDlOperationErrorAttributeCallbackBridge +{ +public: + CHIPDoorLockClusterDlOperationErrorAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPDoorLockClusterDlOperationErrorAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableDoorLockClusterDlOperationErrorAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4257,6 +8283,23 @@ class CHIPNullableDoorLockClusterDlOperationErrorAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableDoorLockClusterDlOperationErrorAttributeCallbackSubscriptionBridge + : public CHIPNullableDoorLockClusterDlOperationErrorAttributeCallbackBridge +{ +public: + CHIPNullableDoorLockClusterDlOperationErrorAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableDoorLockClusterDlOperationErrorAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPDoorLockClusterDlOperationSourceAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4268,6 +8311,23 @@ class CHIPDoorLockClusterDlOperationSourceAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlOperationSource value); }; +class CHIPDoorLockClusterDlOperationSourceAttributeCallbackSubscriptionBridge + : public CHIPDoorLockClusterDlOperationSourceAttributeCallbackBridge +{ +public: + CHIPDoorLockClusterDlOperationSourceAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPDoorLockClusterDlOperationSourceAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableDoorLockClusterDlOperationSourceAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4281,6 +8341,23 @@ class CHIPNullableDoorLockClusterDlOperationSourceAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableDoorLockClusterDlOperationSourceAttributeCallbackSubscriptionBridge + : public CHIPNullableDoorLockClusterDlOperationSourceAttributeCallbackBridge +{ +public: + CHIPNullableDoorLockClusterDlOperationSourceAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableDoorLockClusterDlOperationSourceAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPDoorLockClusterDlStatusAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -4291,6 +8368,22 @@ class CHIPDoorLockClusterDlStatusAttributeCallbackBridge : public CHIPCallbackBr static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlStatus value); }; +class CHIPDoorLockClusterDlStatusAttributeCallbackSubscriptionBridge : public CHIPDoorLockClusterDlStatusAttributeCallbackBridge +{ +public: + CHIPDoorLockClusterDlStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPDoorLockClusterDlStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableDoorLockClusterDlStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4302,6 +8395,23 @@ class CHIPNullableDoorLockClusterDlStatusAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable & value); }; +class CHIPNullableDoorLockClusterDlStatusAttributeCallbackSubscriptionBridge + : public CHIPNullableDoorLockClusterDlStatusAttributeCallbackBridge +{ +public: + CHIPNullableDoorLockClusterDlStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableDoorLockClusterDlStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPDoorLockClusterDlUserStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4313,6 +8423,23 @@ class CHIPDoorLockClusterDlUserStatusAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlUserStatus value); }; +class CHIPDoorLockClusterDlUserStatusAttributeCallbackSubscriptionBridge + : public CHIPDoorLockClusterDlUserStatusAttributeCallbackBridge +{ +public: + CHIPDoorLockClusterDlUserStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPDoorLockClusterDlUserStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableDoorLockClusterDlUserStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4325,6 +8452,23 @@ class CHIPNullableDoorLockClusterDlUserStatusAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableDoorLockClusterDlUserStatusAttributeCallbackSubscriptionBridge + : public CHIPNullableDoorLockClusterDlUserStatusAttributeCallbackBridge +{ +public: + CHIPNullableDoorLockClusterDlUserStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableDoorLockClusterDlUserStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPDoorLockClusterDlUserTypeAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -4335,6 +8479,22 @@ class CHIPDoorLockClusterDlUserTypeAttributeCallbackBridge : public CHIPCallback static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlUserType value); }; +class CHIPDoorLockClusterDlUserTypeAttributeCallbackSubscriptionBridge : public CHIPDoorLockClusterDlUserTypeAttributeCallbackBridge +{ +public: + CHIPDoorLockClusterDlUserTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPDoorLockClusterDlUserTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableDoorLockClusterDlUserTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4347,6 +8507,23 @@ class CHIPNullableDoorLockClusterDlUserTypeAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableDoorLockClusterDlUserTypeAttributeCallbackSubscriptionBridge + : public CHIPNullableDoorLockClusterDlUserTypeAttributeCallbackBridge +{ +public: + CHIPNullableDoorLockClusterDlUserTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableDoorLockClusterDlUserTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4359,6 +8536,23 @@ class CHIPDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DoorLockOperationEventCode value); }; +class CHIPDoorLockClusterDoorLockOperationEventCodeAttributeCallbackSubscriptionBridge + : public CHIPDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge +{ +public: + CHIPDoorLockClusterDoorLockOperationEventCodeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4373,6 +8567,23 @@ class CHIPNullableDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBrid const chip::app::DataModel::Nullable & value); }; +class CHIPNullableDoorLockClusterDoorLockOperationEventCodeAttributeCallbackSubscriptionBridge + : public CHIPNullableDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge +{ +public: + CHIPNullableDoorLockClusterDoorLockOperationEventCodeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4385,6 +8596,23 @@ class CHIPDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DoorLockProgrammingEventCode value); }; +class CHIPDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackSubscriptionBridge + : public CHIPDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge +{ +public: + CHIPDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4399,6 +8627,23 @@ class CHIPNullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBr const chip::app::DataModel::Nullable & value); }; +class CHIPNullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackSubscriptionBridge + : public CHIPNullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge +{ +public: + CHIPNullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4411,6 +8656,23 @@ class CHIPDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DoorLockSetPinOrIdStatus value); }; +class CHIPDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackSubscriptionBridge + : public CHIPDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge +{ +public: + CHIPDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4424,6 +8686,23 @@ class CHIPNullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackSubscriptionBridge + : public CHIPNullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge +{ +public: + CHIPNullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPDoorLockClusterDoorLockUserStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4435,6 +8714,23 @@ class CHIPDoorLockClusterDoorLockUserStatusAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DoorLockUserStatus value); }; +class CHIPDoorLockClusterDoorLockUserStatusAttributeCallbackSubscriptionBridge + : public CHIPDoorLockClusterDoorLockUserStatusAttributeCallbackBridge +{ +public: + CHIPDoorLockClusterDoorLockUserStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPDoorLockClusterDoorLockUserStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableDoorLockClusterDoorLockUserStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4448,6 +8744,23 @@ class CHIPNullableDoorLockClusterDoorLockUserStatusAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableDoorLockClusterDoorLockUserStatusAttributeCallbackSubscriptionBridge + : public CHIPNullableDoorLockClusterDoorLockUserStatusAttributeCallbackBridge +{ +public: + CHIPNullableDoorLockClusterDoorLockUserStatusAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableDoorLockClusterDoorLockUserStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPDoorLockClusterDoorLockUserTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4459,6 +8772,23 @@ class CHIPDoorLockClusterDoorLockUserTypeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DoorLockUserType value); }; +class CHIPDoorLockClusterDoorLockUserTypeAttributeCallbackSubscriptionBridge + : public CHIPDoorLockClusterDoorLockUserTypeAttributeCallbackBridge +{ +public: + CHIPDoorLockClusterDoorLockUserTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPDoorLockClusterDoorLockUserTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableDoorLockClusterDoorLockUserTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4472,6 +8802,23 @@ class CHIPNullableDoorLockClusterDoorLockUserTypeAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableDoorLockClusterDoorLockUserTypeAttributeCallbackSubscriptionBridge + : public CHIPNullableDoorLockClusterDoorLockUserTypeAttributeCallbackBridge +{ +public: + CHIPNullableDoorLockClusterDoorLockUserTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableDoorLockClusterDoorLockUserTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4484,6 +8831,23 @@ class CHIPPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBrid static void OnSuccessFn(void * context, chip::app::Clusters::PumpConfigurationAndControl::PumpControlMode value); }; +class CHIPPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge + : public CHIPPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge +{ +public: + CHIPPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4495,9 +8859,26 @@ class CHIPNullablePumpConfigurationAndControlClusterPumpControlModeAttributeCall CHIPCallbackBridge(queue, handler, action, OnSuccessFn, keepAlive){}; - static void - OnSuccessFn(void * context, - const chip::app::DataModel::Nullable & value); + static void + OnSuccessFn(void * context, + const chip::app::DataModel::Nullable & value); +}; + +class CHIPNullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge + : public CHIPNullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge +{ +public: + CHIPNullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; }; class CHIPPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge @@ -4512,6 +8893,23 @@ class CHIPPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBr static void OnSuccessFn(void * context, chip::app::Clusters::PumpConfigurationAndControl::PumpOperationMode value); }; +class CHIPPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge + : public CHIPPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge +{ +public: + CHIPPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4528,6 +8926,23 @@ class CHIPNullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCa const chip::app::DataModel::Nullable & value); }; +class CHIPNullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge + : public CHIPNullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge +{ +public: + CHIPNullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPThermostatClusterSetpointAdjustModeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4539,6 +8954,23 @@ class CHIPThermostatClusterSetpointAdjustModeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::Thermostat::SetpointAdjustMode value); }; +class CHIPThermostatClusterSetpointAdjustModeAttributeCallbackSubscriptionBridge + : public CHIPThermostatClusterSetpointAdjustModeAttributeCallbackBridge +{ +public: + CHIPThermostatClusterSetpointAdjustModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPThermostatClusterSetpointAdjustModeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableThermostatClusterSetpointAdjustModeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4552,6 +8984,23 @@ class CHIPNullableThermostatClusterSetpointAdjustModeAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableThermostatClusterSetpointAdjustModeAttributeCallbackSubscriptionBridge + : public CHIPNullableThermostatClusterSetpointAdjustModeAttributeCallbackBridge +{ +public: + CHIPNullableThermostatClusterSetpointAdjustModeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableThermostatClusterSetpointAdjustModeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPColorControlClusterColorLoopActionAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4563,6 +9012,23 @@ class CHIPColorControlClusterColorLoopActionAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::ColorControl::ColorLoopAction value); }; +class CHIPColorControlClusterColorLoopActionAttributeCallbackSubscriptionBridge + : public CHIPColorControlClusterColorLoopActionAttributeCallbackBridge +{ +public: + CHIPColorControlClusterColorLoopActionAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPColorControlClusterColorLoopActionAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableColorControlClusterColorLoopActionAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4576,6 +9042,23 @@ class CHIPNullableColorControlClusterColorLoopActionAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableColorControlClusterColorLoopActionAttributeCallbackSubscriptionBridge + : public CHIPNullableColorControlClusterColorLoopActionAttributeCallbackBridge +{ +public: + CHIPNullableColorControlClusterColorLoopActionAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableColorControlClusterColorLoopActionAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPColorControlClusterColorLoopDirectionAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4588,6 +9071,23 @@ class CHIPColorControlClusterColorLoopDirectionAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::ColorControl::ColorLoopDirection value); }; +class CHIPColorControlClusterColorLoopDirectionAttributeCallbackSubscriptionBridge + : public CHIPColorControlClusterColorLoopDirectionAttributeCallbackBridge +{ +public: + CHIPColorControlClusterColorLoopDirectionAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPColorControlClusterColorLoopDirectionAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableColorControlClusterColorLoopDirectionAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4601,6 +9101,23 @@ class CHIPNullableColorControlClusterColorLoopDirectionAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableColorControlClusterColorLoopDirectionAttributeCallbackSubscriptionBridge + : public CHIPNullableColorControlClusterColorLoopDirectionAttributeCallbackBridge +{ +public: + CHIPNullableColorControlClusterColorLoopDirectionAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableColorControlClusterColorLoopDirectionAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPColorControlClusterColorModeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4612,6 +9129,23 @@ class CHIPColorControlClusterColorModeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::ColorControl::ColorMode value); }; +class CHIPColorControlClusterColorModeAttributeCallbackSubscriptionBridge + : public CHIPColorControlClusterColorModeAttributeCallbackBridge +{ +public: + CHIPColorControlClusterColorModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPColorControlClusterColorModeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableColorControlClusterColorModeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4624,6 +9158,23 @@ class CHIPNullableColorControlClusterColorModeAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableColorControlClusterColorModeAttributeCallbackSubscriptionBridge + : public CHIPNullableColorControlClusterColorModeAttributeCallbackBridge +{ +public: + CHIPNullableColorControlClusterColorModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableColorControlClusterColorModeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPColorControlClusterHueDirectionAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4635,6 +9186,23 @@ class CHIPColorControlClusterHueDirectionAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::ColorControl::HueDirection value); }; +class CHIPColorControlClusterHueDirectionAttributeCallbackSubscriptionBridge + : public CHIPColorControlClusterHueDirectionAttributeCallbackBridge +{ +public: + CHIPColorControlClusterHueDirectionAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPColorControlClusterHueDirectionAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableColorControlClusterHueDirectionAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4648,6 +9216,23 @@ class CHIPNullableColorControlClusterHueDirectionAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableColorControlClusterHueDirectionAttributeCallbackSubscriptionBridge + : public CHIPNullableColorControlClusterHueDirectionAttributeCallbackBridge +{ +public: + CHIPNullableColorControlClusterHueDirectionAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableColorControlClusterHueDirectionAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPColorControlClusterHueMoveModeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4659,6 +9244,23 @@ class CHIPColorControlClusterHueMoveModeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::ColorControl::HueMoveMode value); }; +class CHIPColorControlClusterHueMoveModeAttributeCallbackSubscriptionBridge + : public CHIPColorControlClusterHueMoveModeAttributeCallbackBridge +{ +public: + CHIPColorControlClusterHueMoveModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPColorControlClusterHueMoveModeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableColorControlClusterHueMoveModeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4672,6 +9274,23 @@ class CHIPNullableColorControlClusterHueMoveModeAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableColorControlClusterHueMoveModeAttributeCallbackSubscriptionBridge + : public CHIPNullableColorControlClusterHueMoveModeAttributeCallbackBridge +{ +public: + CHIPNullableColorControlClusterHueMoveModeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableColorControlClusterHueMoveModeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPColorControlClusterHueStepModeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4683,6 +9302,23 @@ class CHIPColorControlClusterHueStepModeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::ColorControl::HueStepMode value); }; +class CHIPColorControlClusterHueStepModeAttributeCallbackSubscriptionBridge + : public CHIPColorControlClusterHueStepModeAttributeCallbackBridge +{ +public: + CHIPColorControlClusterHueStepModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPColorControlClusterHueStepModeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableColorControlClusterHueStepModeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4696,6 +9332,23 @@ class CHIPNullableColorControlClusterHueStepModeAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableColorControlClusterHueStepModeAttributeCallbackSubscriptionBridge + : public CHIPNullableColorControlClusterHueStepModeAttributeCallbackBridge +{ +public: + CHIPNullableColorControlClusterHueStepModeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableColorControlClusterHueStepModeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPColorControlClusterSaturationMoveModeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4708,6 +9361,23 @@ class CHIPColorControlClusterSaturationMoveModeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::ColorControl::SaturationMoveMode value); }; +class CHIPColorControlClusterSaturationMoveModeAttributeCallbackSubscriptionBridge + : public CHIPColorControlClusterSaturationMoveModeAttributeCallbackBridge +{ +public: + CHIPColorControlClusterSaturationMoveModeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPColorControlClusterSaturationMoveModeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableColorControlClusterSaturationMoveModeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4721,6 +9391,23 @@ class CHIPNullableColorControlClusterSaturationMoveModeAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableColorControlClusterSaturationMoveModeAttributeCallbackSubscriptionBridge + : public CHIPNullableColorControlClusterSaturationMoveModeAttributeCallbackBridge +{ +public: + CHIPNullableColorControlClusterSaturationMoveModeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableColorControlClusterSaturationMoveModeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPColorControlClusterSaturationStepModeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4733,6 +9420,23 @@ class CHIPColorControlClusterSaturationStepModeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::ColorControl::SaturationStepMode value); }; +class CHIPColorControlClusterSaturationStepModeAttributeCallbackSubscriptionBridge + : public CHIPColorControlClusterSaturationStepModeAttributeCallbackBridge +{ +public: + CHIPColorControlClusterSaturationStepModeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPColorControlClusterSaturationStepModeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableColorControlClusterSaturationStepModeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4746,6 +9450,23 @@ class CHIPNullableColorControlClusterSaturationStepModeAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableColorControlClusterSaturationStepModeAttributeCallbackSubscriptionBridge + : public CHIPNullableColorControlClusterSaturationStepModeAttributeCallbackBridge +{ +public: + CHIPNullableColorControlClusterSaturationStepModeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableColorControlClusterSaturationStepModeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4758,6 +9479,23 @@ class CHIPIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::IlluminanceMeasurement::LightSensorType value); }; +class CHIPIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackSubscriptionBridge + : public CHIPIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge +{ +public: + CHIPIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4773,6 +9511,23 @@ class CHIPNullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackB const chip::app::DataModel::Nullable & value); }; +class CHIPNullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackSubscriptionBridge + : public CHIPNullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge +{ +public: + CHIPNullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPIasZoneClusterIasEnrollResponseCodeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4784,6 +9539,23 @@ class CHIPIasZoneClusterIasEnrollResponseCodeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::IasZone::IasEnrollResponseCode value); }; +class CHIPIasZoneClusterIasEnrollResponseCodeAttributeCallbackSubscriptionBridge + : public CHIPIasZoneClusterIasEnrollResponseCodeAttributeCallbackBridge +{ +public: + CHIPIasZoneClusterIasEnrollResponseCodeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPIasZoneClusterIasEnrollResponseCodeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableIasZoneClusterIasEnrollResponseCodeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4797,6 +9569,23 @@ class CHIPNullableIasZoneClusterIasEnrollResponseCodeAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableIasZoneClusterIasEnrollResponseCodeAttributeCallbackSubscriptionBridge + : public CHIPNullableIasZoneClusterIasEnrollResponseCodeAttributeCallbackBridge +{ +public: + CHIPNullableIasZoneClusterIasEnrollResponseCodeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableIasZoneClusterIasEnrollResponseCodeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPIasZoneClusterIasZoneTypeAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -4807,6 +9596,22 @@ class CHIPIasZoneClusterIasZoneTypeAttributeCallbackBridge : public CHIPCallback static void OnSuccessFn(void * context, chip::app::Clusters::IasZone::IasZoneType value); }; +class CHIPIasZoneClusterIasZoneTypeAttributeCallbackSubscriptionBridge : public CHIPIasZoneClusterIasZoneTypeAttributeCallbackBridge +{ +public: + CHIPIasZoneClusterIasZoneTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPIasZoneClusterIasZoneTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableIasZoneClusterIasZoneTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4819,6 +9624,23 @@ class CHIPNullableIasZoneClusterIasZoneTypeAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableIasZoneClusterIasZoneTypeAttributeCallbackSubscriptionBridge + : public CHIPNullableIasZoneClusterIasZoneTypeAttributeCallbackBridge +{ +public: + CHIPNullableIasZoneClusterIasZoneTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableIasZoneClusterIasZoneTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPIasAceClusterIasAceAlarmStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4830,6 +9652,23 @@ class CHIPIasAceClusterIasAceAlarmStatusAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::IasAce::IasAceAlarmStatus value); }; +class CHIPIasAceClusterIasAceAlarmStatusAttributeCallbackSubscriptionBridge + : public CHIPIasAceClusterIasAceAlarmStatusAttributeCallbackBridge +{ +public: + CHIPIasAceClusterIasAceAlarmStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPIasAceClusterIasAceAlarmStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableIasAceClusterIasAceAlarmStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4843,6 +9682,23 @@ class CHIPNullableIasAceClusterIasAceAlarmStatusAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableIasAceClusterIasAceAlarmStatusAttributeCallbackSubscriptionBridge + : public CHIPNullableIasAceClusterIasAceAlarmStatusAttributeCallbackBridge +{ +public: + CHIPNullableIasAceClusterIasAceAlarmStatusAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableIasAceClusterIasAceAlarmStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPIasAceClusterIasAceArmModeAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -4853,6 +9709,23 @@ class CHIPIasAceClusterIasAceArmModeAttributeCallbackBridge : public CHIPCallbac static void OnSuccessFn(void * context, chip::app::Clusters::IasAce::IasAceArmMode value); }; +class CHIPIasAceClusterIasAceArmModeAttributeCallbackSubscriptionBridge + : public CHIPIasAceClusterIasAceArmModeAttributeCallbackBridge +{ +public: + CHIPIasAceClusterIasAceArmModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPIasAceClusterIasAceArmModeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableIasAceClusterIasAceArmModeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4865,6 +9738,23 @@ class CHIPNullableIasAceClusterIasAceArmModeAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableIasAceClusterIasAceArmModeAttributeCallbackSubscriptionBridge + : public CHIPNullableIasAceClusterIasAceArmModeAttributeCallbackBridge +{ +public: + CHIPNullableIasAceClusterIasAceArmModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableIasAceClusterIasAceArmModeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPIasAceClusterIasAceArmNotificationAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4876,6 +9766,23 @@ class CHIPIasAceClusterIasAceArmNotificationAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::IasAce::IasAceArmNotification value); }; +class CHIPIasAceClusterIasAceArmNotificationAttributeCallbackSubscriptionBridge + : public CHIPIasAceClusterIasAceArmNotificationAttributeCallbackBridge +{ +public: + CHIPIasAceClusterIasAceArmNotificationAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPIasAceClusterIasAceArmNotificationAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableIasAceClusterIasAceArmNotificationAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4889,6 +9796,23 @@ class CHIPNullableIasAceClusterIasAceArmNotificationAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableIasAceClusterIasAceArmNotificationAttributeCallbackSubscriptionBridge + : public CHIPNullableIasAceClusterIasAceArmNotificationAttributeCallbackBridge +{ +public: + CHIPNullableIasAceClusterIasAceArmNotificationAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableIasAceClusterIasAceArmNotificationAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPIasAceClusterIasAceAudibleNotificationAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4901,6 +9825,23 @@ class CHIPIasAceClusterIasAceAudibleNotificationAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::IasAce::IasAceAudibleNotification value); }; +class CHIPIasAceClusterIasAceAudibleNotificationAttributeCallbackSubscriptionBridge + : public CHIPIasAceClusterIasAceAudibleNotificationAttributeCallbackBridge +{ +public: + CHIPIasAceClusterIasAceAudibleNotificationAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPIasAceClusterIasAceAudibleNotificationAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableIasAceClusterIasAceAudibleNotificationAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4914,6 +9855,23 @@ class CHIPNullableIasAceClusterIasAceAudibleNotificationAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableIasAceClusterIasAceAudibleNotificationAttributeCallbackSubscriptionBridge + : public CHIPNullableIasAceClusterIasAceAudibleNotificationAttributeCallbackBridge +{ +public: + CHIPNullableIasAceClusterIasAceAudibleNotificationAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableIasAceClusterIasAceAudibleNotificationAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPIasAceClusterIasAceBypassResultAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4925,6 +9883,23 @@ class CHIPIasAceClusterIasAceBypassResultAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::IasAce::IasAceBypassResult value); }; +class CHIPIasAceClusterIasAceBypassResultAttributeCallbackSubscriptionBridge + : public CHIPIasAceClusterIasAceBypassResultAttributeCallbackBridge +{ +public: + CHIPIasAceClusterIasAceBypassResultAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPIasAceClusterIasAceBypassResultAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableIasAceClusterIasAceBypassResultAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4938,6 +9913,23 @@ class CHIPNullableIasAceClusterIasAceBypassResultAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableIasAceClusterIasAceBypassResultAttributeCallbackSubscriptionBridge + : public CHIPNullableIasAceClusterIasAceBypassResultAttributeCallbackBridge +{ +public: + CHIPNullableIasAceClusterIasAceBypassResultAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableIasAceClusterIasAceBypassResultAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPIasAceClusterIasAcePanelStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4949,6 +9941,23 @@ class CHIPIasAceClusterIasAcePanelStatusAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::IasAce::IasAcePanelStatus value); }; +class CHIPIasAceClusterIasAcePanelStatusAttributeCallbackSubscriptionBridge + : public CHIPIasAceClusterIasAcePanelStatusAttributeCallbackBridge +{ +public: + CHIPIasAceClusterIasAcePanelStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPIasAceClusterIasAcePanelStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableIasAceClusterIasAcePanelStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4962,6 +9971,23 @@ class CHIPNullableIasAceClusterIasAcePanelStatusAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableIasAceClusterIasAcePanelStatusAttributeCallbackSubscriptionBridge + : public CHIPNullableIasAceClusterIasAcePanelStatusAttributeCallbackBridge +{ +public: + CHIPNullableIasAceClusterIasAcePanelStatusAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableIasAceClusterIasAcePanelStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPIasAceClusterIasZoneTypeAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -4972,6 +9998,22 @@ class CHIPIasAceClusterIasZoneTypeAttributeCallbackBridge : public CHIPCallbackB static void OnSuccessFn(void * context, chip::app::Clusters::IasAce::IasZoneType value); }; +class CHIPIasAceClusterIasZoneTypeAttributeCallbackSubscriptionBridge : public CHIPIasAceClusterIasZoneTypeAttributeCallbackBridge +{ +public: + CHIPIasAceClusterIasZoneTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPIasAceClusterIasZoneTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableIasAceClusterIasZoneTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4983,6 +10025,23 @@ class CHIPNullableIasAceClusterIasZoneTypeAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable & value); }; +class CHIPNullableIasAceClusterIasZoneTypeAttributeCallbackSubscriptionBridge + : public CHIPNullableIasAceClusterIasZoneTypeAttributeCallbackBridge +{ +public: + CHIPNullableIasAceClusterIasZoneTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableIasAceClusterIasZoneTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPTvChannelClusterTvChannelErrorTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -4994,6 +10053,23 @@ class CHIPTvChannelClusterTvChannelErrorTypeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::TvChannel::TvChannelErrorType value); }; +class CHIPTvChannelClusterTvChannelErrorTypeAttributeCallbackSubscriptionBridge + : public CHIPTvChannelClusterTvChannelErrorTypeAttributeCallbackBridge +{ +public: + CHIPTvChannelClusterTvChannelErrorTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPTvChannelClusterTvChannelErrorTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableTvChannelClusterTvChannelErrorTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5003,8 +10079,25 @@ class CHIPNullableTvChannelClusterTvChannelErrorTypeAttributeCallbackBridge CHIPCallbackBridge(queue, handler, action, OnSuccessFn, keepAlive){}; - static void OnSuccessFn(void * context, - const chip::app::DataModel::Nullable & value); + static void OnSuccessFn(void * context, + const chip::app::DataModel::Nullable & value); +}; + +class CHIPNullableTvChannelClusterTvChannelErrorTypeAttributeCallbackSubscriptionBridge + : public CHIPNullableTvChannelClusterTvChannelErrorTypeAttributeCallbackBridge +{ +public: + CHIPNullableTvChannelClusterTvChannelErrorTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableTvChannelClusterTvChannelErrorTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; }; class CHIPTvChannelClusterTvChannelLineupInfoTypeAttributeCallbackBridge @@ -5019,6 +10112,23 @@ class CHIPTvChannelClusterTvChannelLineupInfoTypeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::TvChannel::TvChannelLineupInfoType value); }; +class CHIPTvChannelClusterTvChannelLineupInfoTypeAttributeCallbackSubscriptionBridge + : public CHIPTvChannelClusterTvChannelLineupInfoTypeAttributeCallbackBridge +{ +public: + CHIPTvChannelClusterTvChannelLineupInfoTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPTvChannelClusterTvChannelLineupInfoTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableTvChannelClusterTvChannelLineupInfoTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5032,6 +10142,23 @@ class CHIPNullableTvChannelClusterTvChannelLineupInfoTypeAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableTvChannelClusterTvChannelLineupInfoTypeAttributeCallbackSubscriptionBridge + : public CHIPNullableTvChannelClusterTvChannelLineupInfoTypeAttributeCallbackBridge +{ +public: + CHIPNullableTvChannelClusterTvChannelLineupInfoTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableTvChannelClusterTvChannelLineupInfoTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPTargetNavigatorClusterNavigateTargetStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5044,6 +10171,23 @@ class CHIPTargetNavigatorClusterNavigateTargetStatusAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::TargetNavigator::NavigateTargetStatus value); }; +class CHIPTargetNavigatorClusterNavigateTargetStatusAttributeCallbackSubscriptionBridge + : public CHIPTargetNavigatorClusterNavigateTargetStatusAttributeCallbackBridge +{ +public: + CHIPTargetNavigatorClusterNavigateTargetStatusAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPTargetNavigatorClusterNavigateTargetStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableTargetNavigatorClusterNavigateTargetStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5058,6 +10202,23 @@ class CHIPNullableTargetNavigatorClusterNavigateTargetStatusAttributeCallbackBri const chip::app::DataModel::Nullable & value); }; +class CHIPNullableTargetNavigatorClusterNavigateTargetStatusAttributeCallbackSubscriptionBridge + : public CHIPNullableTargetNavigatorClusterNavigateTargetStatusAttributeCallbackBridge +{ +public: + CHIPNullableTargetNavigatorClusterNavigateTargetStatusAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableTargetNavigatorClusterNavigateTargetStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPMediaPlaybackClusterMediaPlaybackStateAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5070,6 +10231,23 @@ class CHIPMediaPlaybackClusterMediaPlaybackStateAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::MediaPlayback::MediaPlaybackState value); }; +class CHIPMediaPlaybackClusterMediaPlaybackStateAttributeCallbackSubscriptionBridge + : public CHIPMediaPlaybackClusterMediaPlaybackStateAttributeCallbackBridge +{ +public: + CHIPMediaPlaybackClusterMediaPlaybackStateAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPMediaPlaybackClusterMediaPlaybackStateAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableMediaPlaybackClusterMediaPlaybackStateAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5083,6 +10261,23 @@ class CHIPNullableMediaPlaybackClusterMediaPlaybackStateAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableMediaPlaybackClusterMediaPlaybackStateAttributeCallbackSubscriptionBridge + : public CHIPNullableMediaPlaybackClusterMediaPlaybackStateAttributeCallbackBridge +{ +public: + CHIPNullableMediaPlaybackClusterMediaPlaybackStateAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableMediaPlaybackClusterMediaPlaybackStateAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPMediaPlaybackClusterMediaPlaybackStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5095,6 +10290,23 @@ class CHIPMediaPlaybackClusterMediaPlaybackStatusAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::MediaPlayback::MediaPlaybackStatus value); }; +class CHIPMediaPlaybackClusterMediaPlaybackStatusAttributeCallbackSubscriptionBridge + : public CHIPMediaPlaybackClusterMediaPlaybackStatusAttributeCallbackBridge +{ +public: + CHIPMediaPlaybackClusterMediaPlaybackStatusAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPMediaPlaybackClusterMediaPlaybackStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableMediaPlaybackClusterMediaPlaybackStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5108,6 +10320,23 @@ class CHIPNullableMediaPlaybackClusterMediaPlaybackStatusAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableMediaPlaybackClusterMediaPlaybackStatusAttributeCallbackSubscriptionBridge + : public CHIPNullableMediaPlaybackClusterMediaPlaybackStatusAttributeCallbackBridge +{ +public: + CHIPNullableMediaPlaybackClusterMediaPlaybackStatusAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableMediaPlaybackClusterMediaPlaybackStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPMediaInputClusterMediaInputTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5119,6 +10348,23 @@ class CHIPMediaInputClusterMediaInputTypeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::MediaInput::MediaInputType value); }; +class CHIPMediaInputClusterMediaInputTypeAttributeCallbackSubscriptionBridge + : public CHIPMediaInputClusterMediaInputTypeAttributeCallbackBridge +{ +public: + CHIPMediaInputClusterMediaInputTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPMediaInputClusterMediaInputTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableMediaInputClusterMediaInputTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5132,6 +10378,23 @@ class CHIPNullableMediaInputClusterMediaInputTypeAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableMediaInputClusterMediaInputTypeAttributeCallbackSubscriptionBridge + : public CHIPNullableMediaInputClusterMediaInputTypeAttributeCallbackBridge +{ +public: + CHIPNullableMediaInputClusterMediaInputTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableMediaInputClusterMediaInputTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPKeypadInputClusterKeypadInputCecKeyCodeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5144,6 +10407,23 @@ class CHIPKeypadInputClusterKeypadInputCecKeyCodeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::KeypadInput::KeypadInputCecKeyCode value); }; +class CHIPKeypadInputClusterKeypadInputCecKeyCodeAttributeCallbackSubscriptionBridge + : public CHIPKeypadInputClusterKeypadInputCecKeyCodeAttributeCallbackBridge +{ +public: + CHIPKeypadInputClusterKeypadInputCecKeyCodeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPKeypadInputClusterKeypadInputCecKeyCodeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableKeypadInputClusterKeypadInputCecKeyCodeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5157,6 +10437,23 @@ class CHIPNullableKeypadInputClusterKeypadInputCecKeyCodeAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableKeypadInputClusterKeypadInputCecKeyCodeAttributeCallbackSubscriptionBridge + : public CHIPNullableKeypadInputClusterKeypadInputCecKeyCodeAttributeCallbackBridge +{ +public: + CHIPNullableKeypadInputClusterKeypadInputCecKeyCodeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableKeypadInputClusterKeypadInputCecKeyCodeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPKeypadInputClusterKeypadInputStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5168,6 +10465,23 @@ class CHIPKeypadInputClusterKeypadInputStatusAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::KeypadInput::KeypadInputStatus value); }; +class CHIPKeypadInputClusterKeypadInputStatusAttributeCallbackSubscriptionBridge + : public CHIPKeypadInputClusterKeypadInputStatusAttributeCallbackBridge +{ +public: + CHIPKeypadInputClusterKeypadInputStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPKeypadInputClusterKeypadInputStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableKeypadInputClusterKeypadInputStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5181,6 +10495,23 @@ class CHIPNullableKeypadInputClusterKeypadInputStatusAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableKeypadInputClusterKeypadInputStatusAttributeCallbackSubscriptionBridge + : public CHIPNullableKeypadInputClusterKeypadInputStatusAttributeCallbackBridge +{ +public: + CHIPNullableKeypadInputClusterKeypadInputStatusAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableKeypadInputClusterKeypadInputStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPContentLauncherClusterContentLaunchMetricTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5193,6 +10524,23 @@ class CHIPContentLauncherClusterContentLaunchMetricTypeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::ContentLauncher::ContentLaunchMetricType value); }; +class CHIPContentLauncherClusterContentLaunchMetricTypeAttributeCallbackSubscriptionBridge + : public CHIPContentLauncherClusterContentLaunchMetricTypeAttributeCallbackBridge +{ +public: + CHIPContentLauncherClusterContentLaunchMetricTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPContentLauncherClusterContentLaunchMetricTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableContentLauncherClusterContentLaunchMetricTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5209,6 +10557,23 @@ class CHIPNullableContentLauncherClusterContentLaunchMetricTypeAttributeCallback const chip::app::DataModel::Nullable & value); }; +class CHIPNullableContentLauncherClusterContentLaunchMetricTypeAttributeCallbackSubscriptionBridge + : public CHIPNullableContentLauncherClusterContentLaunchMetricTypeAttributeCallbackBridge +{ +public: + CHIPNullableContentLauncherClusterContentLaunchMetricTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableContentLauncherClusterContentLaunchMetricTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPContentLauncherClusterContentLaunchParameterEnumAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5221,6 +10586,23 @@ class CHIPContentLauncherClusterContentLaunchParameterEnumAttributeCallbackBridg static void OnSuccessFn(void * context, chip::app::Clusters::ContentLauncher::ContentLaunchParameterEnum value); }; +class CHIPContentLauncherClusterContentLaunchParameterEnumAttributeCallbackSubscriptionBridge + : public CHIPContentLauncherClusterContentLaunchParameterEnumAttributeCallbackBridge +{ +public: + CHIPContentLauncherClusterContentLaunchParameterEnumAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPContentLauncherClusterContentLaunchParameterEnumAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableContentLauncherClusterContentLaunchParameterEnumAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5237,6 +10619,23 @@ class CHIPNullableContentLauncherClusterContentLaunchParameterEnumAttributeCallb const chip::app::DataModel::Nullable & value); }; +class CHIPNullableContentLauncherClusterContentLaunchParameterEnumAttributeCallbackSubscriptionBridge + : public CHIPNullableContentLauncherClusterContentLaunchParameterEnumAttributeCallbackBridge +{ +public: + CHIPNullableContentLauncherClusterContentLaunchParameterEnumAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableContentLauncherClusterContentLaunchParameterEnumAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPContentLauncherClusterContentLaunchStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5249,6 +10648,23 @@ class CHIPContentLauncherClusterContentLaunchStatusAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::ContentLauncher::ContentLaunchStatus value); }; +class CHIPContentLauncherClusterContentLaunchStatusAttributeCallbackSubscriptionBridge + : public CHIPContentLauncherClusterContentLaunchStatusAttributeCallbackBridge +{ +public: + CHIPContentLauncherClusterContentLaunchStatusAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPContentLauncherClusterContentLaunchStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableContentLauncherClusterContentLaunchStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5263,6 +10679,23 @@ class CHIPNullableContentLauncherClusterContentLaunchStatusAttributeCallbackBrid const chip::app::DataModel::Nullable & value); }; +class CHIPNullableContentLauncherClusterContentLaunchStatusAttributeCallbackSubscriptionBridge + : public CHIPNullableContentLauncherClusterContentLaunchStatusAttributeCallbackBridge +{ +public: + CHIPNullableContentLauncherClusterContentLaunchStatusAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableContentLauncherClusterContentLaunchStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPContentLauncherClusterContentLaunchStreamingTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5275,6 +10708,23 @@ class CHIPContentLauncherClusterContentLaunchStreamingTypeAttributeCallbackBridg static void OnSuccessFn(void * context, chip::app::Clusters::ContentLauncher::ContentLaunchStreamingType value); }; +class CHIPContentLauncherClusterContentLaunchStreamingTypeAttributeCallbackSubscriptionBridge + : public CHIPContentLauncherClusterContentLaunchStreamingTypeAttributeCallbackBridge +{ +public: + CHIPContentLauncherClusterContentLaunchStreamingTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPContentLauncherClusterContentLaunchStreamingTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableContentLauncherClusterContentLaunchStreamingTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5291,6 +10741,23 @@ class CHIPNullableContentLauncherClusterContentLaunchStreamingTypeAttributeCallb const chip::app::DataModel::Nullable & value); }; +class CHIPNullableContentLauncherClusterContentLaunchStreamingTypeAttributeCallbackSubscriptionBridge + : public CHIPNullableContentLauncherClusterContentLaunchStreamingTypeAttributeCallbackBridge +{ +public: + CHIPNullableContentLauncherClusterContentLaunchStreamingTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableContentLauncherClusterContentLaunchStreamingTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPAudioOutputClusterAudioOutputTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5302,6 +10769,23 @@ class CHIPAudioOutputClusterAudioOutputTypeAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::AudioOutput::AudioOutputType value); }; +class CHIPAudioOutputClusterAudioOutputTypeAttributeCallbackSubscriptionBridge + : public CHIPAudioOutputClusterAudioOutputTypeAttributeCallbackBridge +{ +public: + CHIPAudioOutputClusterAudioOutputTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPAudioOutputClusterAudioOutputTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableAudioOutputClusterAudioOutputTypeAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5315,6 +10799,23 @@ class CHIPNullableAudioOutputClusterAudioOutputTypeAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableAudioOutputClusterAudioOutputTypeAttributeCallbackSubscriptionBridge + : public CHIPNullableAudioOutputClusterAudioOutputTypeAttributeCallbackBridge +{ +public: + CHIPNullableAudioOutputClusterAudioOutputTypeAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableAudioOutputClusterAudioOutputTypeAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPApplicationLauncherClusterApplicationLauncherStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5327,6 +10828,23 @@ class CHIPApplicationLauncherClusterApplicationLauncherStatusAttributeCallbackBr static void OnSuccessFn(void * context, chip::app::Clusters::ApplicationLauncher::ApplicationLauncherStatus value); }; +class CHIPApplicationLauncherClusterApplicationLauncherStatusAttributeCallbackSubscriptionBridge + : public CHIPApplicationLauncherClusterApplicationLauncherStatusAttributeCallbackBridge +{ +public: + CHIPApplicationLauncherClusterApplicationLauncherStatusAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPApplicationLauncherClusterApplicationLauncherStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableApplicationLauncherClusterApplicationLauncherStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5343,6 +10861,23 @@ class CHIPNullableApplicationLauncherClusterApplicationLauncherStatusAttributeCa const chip::app::DataModel::Nullable & value); }; +class CHIPNullableApplicationLauncherClusterApplicationLauncherStatusAttributeCallbackSubscriptionBridge + : public CHIPNullableApplicationLauncherClusterApplicationLauncherStatusAttributeCallbackBridge +{ +public: + CHIPNullableApplicationLauncherClusterApplicationLauncherStatusAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableApplicationLauncherClusterApplicationLauncherStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPApplicationBasicClusterApplicationBasicStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5355,6 +10890,23 @@ class CHIPApplicationBasicClusterApplicationBasicStatusAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::ApplicationBasic::ApplicationBasicStatus value); }; +class CHIPApplicationBasicClusterApplicationBasicStatusAttributeCallbackSubscriptionBridge + : public CHIPApplicationBasicClusterApplicationBasicStatusAttributeCallbackBridge +{ +public: + CHIPApplicationBasicClusterApplicationBasicStatusAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPApplicationBasicClusterApplicationBasicStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableApplicationBasicClusterApplicationBasicStatusAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5371,6 +10923,23 @@ class CHIPNullableApplicationBasicClusterApplicationBasicStatusAttributeCallback const chip::app::DataModel::Nullable & value); }; +class CHIPNullableApplicationBasicClusterApplicationBasicStatusAttributeCallbackSubscriptionBridge + : public CHIPNullableApplicationBasicClusterApplicationBasicStatusAttributeCallbackBridge +{ +public: + CHIPNullableApplicationBasicClusterApplicationBasicStatusAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableApplicationBasicClusterApplicationBasicStatusAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPTestClusterClusterSimpleEnumAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5382,6 +10951,23 @@ class CHIPTestClusterClusterSimpleEnumAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::TestCluster::SimpleEnum value); }; +class CHIPTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge + : public CHIPTestClusterClusterSimpleEnumAttributeCallbackBridge +{ +public: + CHIPTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPTestClusterClusterSimpleEnumAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableTestClusterClusterSimpleEnumAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5394,6 +10980,23 @@ class CHIPNullableTestClusterClusterSimpleEnumAttributeCallbackBridge const chip::app::DataModel::Nullable & value); }; +class CHIPNullableTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge + : public CHIPNullableTestClusterClusterSimpleEnumAttributeCallbackBridge +{ +public: + CHIPNullableTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableTestClusterClusterSimpleEnumAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPMessagingClusterEventIdAttributeCallbackBridge : public CHIPCallbackBridge { public: @@ -5404,6 +11007,22 @@ class CHIPMessagingClusterEventIdAttributeCallbackBridge : public CHIPCallbackBr static void OnSuccessFn(void * context, chip::app::Clusters::Messaging::EventId value); }; +class CHIPMessagingClusterEventIdAttributeCallbackSubscriptionBridge : public CHIPMessagingClusterEventIdAttributeCallbackBridge +{ +public: + CHIPMessagingClusterEventIdAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPMessagingClusterEventIdAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableMessagingClusterEventIdAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5415,6 +11034,23 @@ class CHIPNullableMessagingClusterEventIdAttributeCallbackBridge static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable & value); }; +class CHIPNullableMessagingClusterEventIdAttributeCallbackSubscriptionBridge + : public CHIPNullableMessagingClusterEventIdAttributeCallbackBridge +{ +public: + CHIPNullableMessagingClusterEventIdAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableMessagingClusterEventIdAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPMessagingClusterMessagingControlConfirmationAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5427,6 +11063,23 @@ class CHIPMessagingClusterMessagingControlConfirmationAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::Messaging::MessagingControlConfirmation value); }; +class CHIPMessagingClusterMessagingControlConfirmationAttributeCallbackSubscriptionBridge + : public CHIPMessagingClusterMessagingControlConfirmationAttributeCallbackBridge +{ +public: + CHIPMessagingClusterMessagingControlConfirmationAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPMessagingClusterMessagingControlConfirmationAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableMessagingClusterMessagingControlConfirmationAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5442,6 +11095,23 @@ class CHIPNullableMessagingClusterMessagingControlConfirmationAttributeCallbackB const chip::app::DataModel::Nullable & value); }; +class CHIPNullableMessagingClusterMessagingControlConfirmationAttributeCallbackSubscriptionBridge + : public CHIPNullableMessagingClusterMessagingControlConfirmationAttributeCallbackBridge +{ +public: + CHIPNullableMessagingClusterMessagingControlConfirmationAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableMessagingClusterMessagingControlConfirmationAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPMessagingClusterMessagingControlEnhancedConfirmationAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5455,6 +11125,23 @@ class CHIPMessagingClusterMessagingControlEnhancedConfirmationAttributeCallbackB static void OnSuccessFn(void * context, chip::app::Clusters::Messaging::MessagingControlEnhancedConfirmation value); }; +class CHIPMessagingClusterMessagingControlEnhancedConfirmationAttributeCallbackSubscriptionBridge + : public CHIPMessagingClusterMessagingControlEnhancedConfirmationAttributeCallbackBridge +{ +public: + CHIPMessagingClusterMessagingControlEnhancedConfirmationAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPMessagingClusterMessagingControlEnhancedConfirmationAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableMessagingClusterMessagingControlEnhancedConfirmationAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5471,6 +11158,23 @@ class CHIPNullableMessagingClusterMessagingControlEnhancedConfirmationAttributeC const chip::app::DataModel::Nullable & value); }; +class CHIPNullableMessagingClusterMessagingControlEnhancedConfirmationAttributeCallbackSubscriptionBridge + : public CHIPNullableMessagingClusterMessagingControlEnhancedConfirmationAttributeCallbackBridge +{ +public: + CHIPNullableMessagingClusterMessagingControlEnhancedConfirmationAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableMessagingClusterMessagingControlEnhancedConfirmationAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPMessagingClusterMessagingControlImportanceAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5483,6 +11187,23 @@ class CHIPMessagingClusterMessagingControlImportanceAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::Messaging::MessagingControlImportance value); }; +class CHIPMessagingClusterMessagingControlImportanceAttributeCallbackSubscriptionBridge + : public CHIPMessagingClusterMessagingControlImportanceAttributeCallbackBridge +{ +public: + CHIPMessagingClusterMessagingControlImportanceAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPMessagingClusterMessagingControlImportanceAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableMessagingClusterMessagingControlImportanceAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5497,6 +11218,23 @@ class CHIPNullableMessagingClusterMessagingControlImportanceAttributeCallbackBri const chip::app::DataModel::Nullable & value); }; +class CHIPNullableMessagingClusterMessagingControlImportanceAttributeCallbackSubscriptionBridge + : public CHIPNullableMessagingClusterMessagingControlImportanceAttributeCallbackBridge +{ +public: + CHIPNullableMessagingClusterMessagingControlImportanceAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableMessagingClusterMessagingControlImportanceAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPMessagingClusterMessagingControlTransmissionAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5509,6 +11247,23 @@ class CHIPMessagingClusterMessagingControlTransmissionAttributeCallbackBridge static void OnSuccessFn(void * context, chip::app::Clusters::Messaging::MessagingControlTransmission value); }; +class CHIPMessagingClusterMessagingControlTransmissionAttributeCallbackSubscriptionBridge + : public CHIPMessagingClusterMessagingControlTransmissionAttributeCallbackBridge +{ +public: + CHIPMessagingClusterMessagingControlTransmissionAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPMessagingClusterMessagingControlTransmissionAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableMessagingClusterMessagingControlTransmissionAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5524,6 +11279,23 @@ class CHIPNullableMessagingClusterMessagingControlTransmissionAttributeCallbackB const chip::app::DataModel::Nullable & value); }; +class CHIPNullableMessagingClusterMessagingControlTransmissionAttributeCallbackSubscriptionBridge + : public CHIPNullableMessagingClusterMessagingControlTransmissionAttributeCallbackBridge +{ +public: + CHIPNullableMessagingClusterMessagingControlTransmissionAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableMessagingClusterMessagingControlTransmissionAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPApplianceEventsAndAlertClusterEventIdentificationAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5536,6 +11308,23 @@ class CHIPApplianceEventsAndAlertClusterEventIdentificationAttributeCallbackBrid static void OnSuccessFn(void * context, chip::app::Clusters::ApplianceEventsAndAlert::EventIdentification value); }; +class CHIPApplianceEventsAndAlertClusterEventIdentificationAttributeCallbackSubscriptionBridge + : public CHIPApplianceEventsAndAlertClusterEventIdentificationAttributeCallbackBridge +{ +public: + CHIPApplianceEventsAndAlertClusterEventIdentificationAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPApplianceEventsAndAlertClusterEventIdentificationAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; + class CHIPNullableApplianceEventsAndAlertClusterEventIdentificationAttributeCallbackBridge : public CHIPCallbackBridge { @@ -5551,3 +11340,20 @@ class CHIPNullableApplianceEventsAndAlertClusterEventIdentificationAttributeCall OnSuccessFn(void * context, const chip::app::DataModel::Nullable & value); }; + +class CHIPNullableApplianceEventsAndAlertClusterEventIdentificationAttributeCallbackSubscriptionBridge + : public CHIPNullableApplianceEventsAndAlertClusterEventIdentificationAttributeCallbackBridge +{ +public: + CHIPNullableApplianceEventsAndAlertClusterEventIdentificationAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + SubscriptionEstablishedHandler establishedHandler) : + CHIPNullableApplianceEventsAndAlertClusterEventIdentificationAttributeCallbackBridge(queue, handler, action, true), + mEstablishedHandler(establishedHandler) + {} + + static void OnSubscriptionEstablished(void * context); + +private: + SubscriptionEstablishedHandler mEstablishedHandler; +}; diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h index c9683253ae02cd..3296c7a74a5fe7 100644 --- a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h +++ b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h @@ -25,8 +25,9 @@ #include #include -typedef void (^ResponseHandler)(NSError * _Nullable error, id _Nullable values); +typedef void (^ResponseHandler)(id _Nullable value, NSError * _Nullable error); typedef void (^StatusCompletion)(NSError * _Nullable error); +typedef void (^SubscriptionEstablishedHandler)(void); NS_ASSUME_NONNULL_BEGIN @@ -38,10 +39,18 @@ NS_ASSUME_NONNULL_BEGIN - (void)readAttributeAclWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeAclWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; +- (void)subscribeAttributeAclWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeExtensionWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeExtensionWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; +- (void)subscribeAttributeExtensionWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -69,9 +78,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -103,9 +112,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -122,56 +131,54 @@ NS_ASSUME_NONNULL_BEGIN NSString * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeVendorNameWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeVendorNameWithResponseHandler:(void (^)( - NSString * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeVendorIdWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeVendorIdWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeVendorIdWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeApplicationNameWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeApplicationNameWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeApplicationNameWithResponseHandler:(void (^)(NSString * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeProductIdWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeProductIdWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeProductIdWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeApplicationIdWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeApplicationIdWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeApplicationIdWithResponseHandler:(void (^)( - NSString * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeCatalogVendorIdWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeCatalogVendorIdWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeCatalogVendorIdWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeApplicationStatusWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeApplicationStatusWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeApplicationStatusWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -180,9 +187,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -198,22 +205,28 @@ NS_ASSUME_NONNULL_BEGIN - (void)readAttributeApplicationLauncherListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)subscribeAttributeApplicationLauncherListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeCatalogVendorIdWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeCatalogVendorIdWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeCatalogVendorIdWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeApplicationIdWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeApplicationIdWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeApplicationIdWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -222,9 +235,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -241,14 +254,19 @@ NS_ASSUME_NONNULL_BEGIN - (void)readAttributeAudioOutputListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)subscribeAttributeAudioOutputListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeCurrentAudioOutputWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeCurrentAudioOutputWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeCurrentAudioOutputWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -257,9 +275,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -277,33 +295,35 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeBarrierMovingStateWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeBarrierMovingStateWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeBarrierSafetyStatusWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeBarrierSafetyStatusWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeBarrierSafetyStatusWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeBarrierCapabilitiesWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeBarrierCapabilitiesWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeBarrierCapabilitiesWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeBarrierPositionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeBarrierPositionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeBarrierPositionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -312,9 +332,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -330,146 +350,143 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeInteractionModelVersionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeInteractionModelVersionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeVendorNameWithCompletionHandler:(void (^)( NSString * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeVendorNameWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeVendorNameWithResponseHandler:(void (^)( - NSString * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeVendorIDWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeVendorIDWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeVendorIDWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeProductNameWithCompletionHandler:(void (^)( NSString * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeProductNameWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeProductNameWithResponseHandler:(void (^)( - NSString * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeProductIDWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeProductIDWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeProductIDWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNodeLabelWithCompletionHandler:(void (^)( NSString * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeNodeLabelWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeNodeLabelWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNodeLabelWithResponseHandler:(void (^)( - NSString * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeLocationWithCompletionHandler:(void (^)( NSString * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeLocationWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeLocationWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeLocationWithResponseHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeHardwareVersionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeHardwareVersionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeHardwareVersionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeHardwareVersionStringWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeHardwareVersionStringWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeHardwareVersionStringWithResponseHandler:(void (^)(NSString * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeSoftwareVersionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeSoftwareVersionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeSoftwareVersionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeSoftwareVersionStringWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeSoftwareVersionStringWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeSoftwareVersionStringWithResponseHandler:(void (^)(NSString * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeManufacturingDateWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeManufacturingDateWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeManufacturingDateWithResponseHandler:(void (^)(NSString * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePartNumberWithCompletionHandler:(void (^)( NSString * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePartNumberWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePartNumberWithResponseHandler:(void (^)( - NSString * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeProductURLWithCompletionHandler:(void (^)( NSString * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeProductURLWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeProductURLWithResponseHandler:(void (^)( - NSString * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeProductLabelWithCompletionHandler:(void (^)( NSString * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeProductLabelWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeProductLabelWithResponseHandler:(void (^)( - NSString * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeSerialNumberWithCompletionHandler:(void (^)( NSString * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeSerialNumberWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeSerialNumberWithResponseHandler:(void (^)( - NSString * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeLocalConfigDisabledWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeLocalConfigDisabledWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeLocalConfigDisabledWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeLocalConfigDisabledWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeReachableWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeReachableWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeReachableWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeUniqueIDWithCompletionHandler:(void (^)( NSString * _Nullable value, NSError * _Nullable error))completionHandler; @@ -481,9 +498,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -498,26 +515,25 @@ NS_ASSUME_NONNULL_BEGIN - (void)writeAttributeOutOfServiceWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeOutOfServiceWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeOutOfServiceWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePresentValueWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributePresentValueWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributePresentValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePresentValueWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeStatusFlagsWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeStatusFlagsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeStatusFlagsWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -526,9 +542,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -548,9 +564,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -564,9 +580,8 @@ NS_ASSUME_NONNULL_BEGIN NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeStateValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeStateValueWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -575,9 +590,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -614,16 +629,24 @@ NS_ASSUME_NONNULL_BEGIN - (void)readAttributeActionListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)subscribeAttributeActionListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeEndpointListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)subscribeAttributeEndpointListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeSetupUrlWithCompletionHandler:(void (^)( NSString * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeSetupUrlWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeSetupUrlWithResponseHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -632,9 +655,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -651,9 +674,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -701,268 +724,253 @@ NS_ASSUME_NONNULL_BEGIN NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeCurrentHueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeCurrentHueWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeCurrentSaturationWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeCurrentSaturationWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeCurrentSaturationWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeRemainingTimeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeRemainingTimeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeRemainingTimeWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeCurrentXWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeCurrentXWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeCurrentXWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeCurrentYWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeCurrentYWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeCurrentYWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeDriftCompensationWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeDriftCompensationWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeDriftCompensationWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeCompensationTextWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeCompensationTextWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeCompensationTextWithResponseHandler:(void (^)(NSString * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeColorTemperatureWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeColorTemperatureWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeColorTemperatureWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeColorModeWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeColorModeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeColorModeWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeColorControlOptionsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeColorControlOptionsWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeColorControlOptionsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeColorControlOptionsWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNumberOfPrimariesWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeNumberOfPrimariesWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNumberOfPrimariesWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePrimary1XWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePrimary1XWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePrimary1XWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePrimary1YWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePrimary1YWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePrimary1YWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePrimary1IntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePrimary1IntensityWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePrimary1IntensityWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePrimary2XWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePrimary2XWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePrimary2XWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePrimary2YWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePrimary2YWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePrimary2YWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePrimary2IntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePrimary2IntensityWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePrimary2IntensityWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePrimary3XWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePrimary3XWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePrimary3XWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePrimary3YWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePrimary3YWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePrimary3YWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePrimary3IntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePrimary3IntensityWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePrimary3IntensityWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePrimary4XWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePrimary4XWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePrimary4XWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePrimary4YWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePrimary4YWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePrimary4YWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePrimary4IntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePrimary4IntensityWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePrimary4IntensityWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePrimary5XWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePrimary5XWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePrimary5XWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePrimary5YWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePrimary5YWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePrimary5YWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePrimary5IntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePrimary5IntensityWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePrimary5IntensityWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePrimary6XWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePrimary6XWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePrimary6XWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePrimary6YWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePrimary6YWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePrimary6YWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePrimary6IntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePrimary6IntensityWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePrimary6IntensityWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeWhitePointXWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeWhitePointXWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeWhitePointXWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeWhitePointXWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeWhitePointYWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeWhitePointYWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeWhitePointYWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeWhitePointYWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeColorPointRXWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeColorPointRXWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeColorPointRXWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeColorPointRXWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeColorPointRYWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeColorPointRYWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeColorPointRYWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeColorPointRYWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeColorPointRIntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; @@ -970,27 +978,28 @@ NS_ASSUME_NONNULL_BEGIN completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeColorPointRIntensityWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeColorPointRIntensityWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeColorPointGXWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeColorPointGXWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeColorPointGXWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeColorPointGXWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeColorPointGYWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeColorPointGYWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeColorPointGYWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeColorPointGYWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeColorPointGIntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; @@ -998,27 +1007,28 @@ NS_ASSUME_NONNULL_BEGIN completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeColorPointGIntensityWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeColorPointGIntensityWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeColorPointBXWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeColorPointBXWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeColorPointBXWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeColorPointBXWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeColorPointBYWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeColorPointBYWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeColorPointBYWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeColorPointBYWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeColorPointBIntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; @@ -1026,97 +1036,103 @@ NS_ASSUME_NONNULL_BEGIN completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeColorPointBIntensityWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeColorPointBIntensityWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeEnhancedCurrentHueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeEnhancedCurrentHueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeEnhancedCurrentHueWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeEnhancedColorModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeEnhancedColorModeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeEnhancedColorModeWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeColorLoopActiveWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeColorLoopActiveWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeColorLoopActiveWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeColorLoopDirectionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeColorLoopDirectionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeColorLoopDirectionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeColorLoopTimeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeColorLoopTimeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeColorLoopTimeWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeColorLoopStartEnhancedHueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeColorLoopStartEnhancedHueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeColorLoopStartEnhancedHueWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeColorLoopStoredEnhancedHueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeColorLoopStoredEnhancedHueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeColorLoopStoredEnhancedHueWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeColorCapabilitiesWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeColorCapabilitiesWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeColorCapabilitiesWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeColorTempPhysicalMinWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeColorTempPhysicalMinWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeColorTempPhysicalMinWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeColorTempPhysicalMaxWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeColorTempPhysicalMaxWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeColorTempPhysicalMaxWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeCoupleColorTempToLevelMinMiredsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeCoupleColorTempToLevelMinMiredsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeCoupleColorTempToLevelMinMiredsWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeStartUpColorTemperatureMiredsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; @@ -1124,9 +1140,10 @@ NS_ASSUME_NONNULL_BEGIN completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeStartUpColorTemperatureMiredsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeStartUpColorTemperatureMiredsWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -1135,9 +1152,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -1156,9 +1173,20 @@ NS_ASSUME_NONNULL_BEGIN - (void)readAttributeAcceptsHeaderListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)subscribeAttributeAcceptsHeaderListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeSupportedStreamingTypesWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)subscribeAttributeSupportedStreamingTypesWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -1167,9 +1195,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -1181,15 +1209,31 @@ NS_ASSUME_NONNULL_BEGIN - (void)readAttributeDeviceListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)subscribeAttributeDeviceListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeServerListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)subscribeAttributeServerListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeClientListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)subscribeAttributeClientListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePartsListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)subscribeAttributePartsListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -1198,9 +1242,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -1278,24 +1322,23 @@ NS_ASSUME_NONNULL_BEGIN NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeLockStateWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeLockStateWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeLockTypeWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeLockTypeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeLockTypeWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeActuatorEnabledWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeActuatorEnabledWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeActuatorEnabledWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -1304,9 +1347,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -1320,89 +1363,86 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMeasurementTypeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMeasurementTypeWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeTotalActivePowerWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeTotalActivePowerWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeTotalActivePowerWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeRmsVoltageWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeRmsVoltageWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeRmsVoltageWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeRmsVoltageMinWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeRmsVoltageMinWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeRmsVoltageMinWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeRmsVoltageMaxWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeRmsVoltageMaxWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeRmsVoltageMaxWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeRmsCurrentWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeRmsCurrentWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeRmsCurrentWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeRmsCurrentMinWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeRmsCurrentMinWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeRmsCurrentMinWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeRmsCurrentMaxWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeRmsCurrentMaxWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeRmsCurrentMaxWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeActivePowerWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeActivePowerWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeActivePowerWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeActivePowerMinWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeActivePowerMinWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeActivePowerMinWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeActivePowerMaxWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeActivePowerMaxWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeActivePowerMaxWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -1411,9 +1451,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -1429,72 +1469,70 @@ NS_ASSUME_NONNULL_BEGIN NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePHYRateWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePHYRateWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeFullDuplexWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeFullDuplexWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeFullDuplexWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePacketRxCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePacketRxCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePacketRxCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePacketTxCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePacketTxCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePacketTxCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeTxErrCountWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeTxErrCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeTxErrCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeCollisionCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeCollisionCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeCollisionCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeOverrunCountWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeOverrunCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeOverrunCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeCarrierDetectWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeCarrierDetectWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeCarrierDetectWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeTimeSinceResetWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeTimeSinceResetWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeTimeSinceResetWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -1506,9 +1544,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -1520,6 +1558,10 @@ NS_ASSUME_NONNULL_BEGIN - (void)readAttributeLabelListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)subscribeAttributeLabelListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -1528,9 +1570,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -1544,33 +1586,32 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMeasuredValueWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeMinMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMinMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMinMeasuredValueWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeMaxMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMaxMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMaxMeasuredValueWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeToleranceWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeToleranceWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeToleranceWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -1579,9 +1620,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -1606,12 +1647,17 @@ NS_ASSUME_NONNULL_BEGIN - (void)writeAttributeBreadcrumbWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeBreadcrumbWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeBreadcrumbWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeBasicCommissioningInfoListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)subscribeAttributeBasicCommissioningInfoListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeRegulatoryConfigWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; @@ -1626,9 +1672,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -1640,45 +1686,66 @@ NS_ASSUME_NONNULL_BEGIN - (void)readAttributeNetworkInterfacesWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)subscribeAttributeNetworkInterfacesWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeRebootCountWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeRebootCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeRebootCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeUpTimeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeUpTimeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeUpTimeWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeTotalOperationalHoursWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeTotalOperationalHoursWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeTotalOperationalHoursWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeBootReasonsWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeBootReasonsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeBootReasonsWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeActiveHardwareFaultsWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)subscribeAttributeActiveHardwareFaultsWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeActiveRadioFaultsWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)subscribeAttributeActiveRadioFaultsWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeActiveNetworkFaultsWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)subscribeAttributeActiveNetworkFaultsWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -1687,9 +1754,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -1700,9 +1767,17 @@ NS_ASSUME_NONNULL_BEGIN @interface CHIPGroupKeyManagement : CHIPCluster - (void)readAttributeGroupsWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)subscribeAttributeGroupsWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeGroupKeysWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)subscribeAttributeGroupKeysWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -1711,9 +1786,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -1743,9 +1818,8 @@ NS_ASSUME_NONNULL_BEGIN NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeNameSupportWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNameSupportWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -1754,9 +1828,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -1777,17 +1851,17 @@ NS_ASSUME_NONNULL_BEGIN - (void)writeAttributeIdentifyTimeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeIdentifyTimeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeIdentifyTimeWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeIdentifyTypeWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeIdentifyTypeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeIdentifyTypeWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -1796,9 +1870,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -1812,41 +1886,40 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMeasuredValueWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeMinMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMinMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMinMeasuredValueWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeMaxMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMaxMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMaxMeasuredValueWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeToleranceWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeToleranceWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeToleranceWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeLightSensorTypeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeLightSensorTypeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeLightSensorTypeWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -1855,9 +1928,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -1878,9 +1951,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -1907,116 +1980,118 @@ NS_ASSUME_NONNULL_BEGIN NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeCurrentLevelWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeCurrentLevelWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeRemainingTimeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeRemainingTimeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeRemainingTimeWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeMinLevelWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMinLevelWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMinLevelWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeMaxLevelWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMaxLevelWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMaxLevelWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeCurrentFrequencyWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeCurrentFrequencyWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeCurrentFrequencyWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeMinFrequencyWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMinFrequencyWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMinFrequencyWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeMaxFrequencyWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMaxFrequencyWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMaxFrequencyWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeOptionsWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeOptionsWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeOptionsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeOptionsWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeOnOffTransitionTimeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeOnOffTransitionTimeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeOnOffTransitionTimeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeOnOffTransitionTimeWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeOnLevelWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeOnLevelWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeOnLevelWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeOnLevelWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeOnTransitionTimeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeOnTransitionTimeWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeOnTransitionTimeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeOnTransitionTimeWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeOffTransitionTimeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeOffTransitionTimeWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeOffTransitionTimeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeOffTransitionTimeWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeDefaultMoveRateWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeDefaultMoveRateWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeDefaultMoveRateWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeDefaultMoveRateWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeStartUpCurrentLevelWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeStartUpCurrentLevelWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeStartUpCurrentLevelWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeStartUpCurrentLevelWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -2025,9 +2100,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -2046,9 +2121,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -2067,14 +2142,19 @@ NS_ASSUME_NONNULL_BEGIN - (void)readAttributeMediaInputListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)subscribeAttributeMediaInputListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeCurrentMediaInputWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeCurrentMediaInputWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeCurrentMediaInputWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -2083,9 +2163,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -2125,63 +2205,62 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributePlaybackStateWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePlaybackStateWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeStartTimeWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeStartTimeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeStartTimeWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeDurationWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeDurationWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeDurationWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePositionUpdatedAtWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePositionUpdatedAtWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePositionUpdatedAtWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePositionWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePositionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePositionWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePlaybackSpeedWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePlaybackSpeedWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePlaybackSpeedWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeSeekRangeEndWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeSeekRangeEndWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeSeekRangeEndWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeSeekRangeStartWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeSeekRangeStartWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeSeekRangeStartWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -2190,9 +2269,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -2209,35 +2288,37 @@ NS_ASSUME_NONNULL_BEGIN NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeCurrentModeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeCurrentModeWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeSupportedModesWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)subscribeAttributeSupportedModesWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeOnModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeOnModeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeOnModeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeOnModeWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeStartUpModeWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeStartUpModeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeStartUpModeWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeDescriptionWithCompletionHandler:(void (^)( NSString * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeDescriptionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeDescriptionWithResponseHandler:(void (^)( - NSString * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -2246,9 +2327,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -2290,17 +2371,16 @@ NS_ASSUME_NONNULL_BEGIN NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeFeatureMapWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeFeatureMapWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -2326,9 +2406,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -2346,17 +2426,17 @@ NS_ASSUME_NONNULL_BEGIN - (void)writeAttributeDefaultOtaProviderWithValue:(NSData * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeDefaultOtaProviderWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeDefaultOtaProviderWithResponseHandler:(void (^)(NSData * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeUpdatePossibleWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeUpdatePossibleWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeUpdatePossibleWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -2365,9 +2445,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -2381,25 +2461,26 @@ NS_ASSUME_NONNULL_BEGIN NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeOccupancyWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeOccupancyWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeOccupancySensorTypeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeOccupancySensorTypeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeOccupancySensorTypeWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeOccupancySensorTypeBitmapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeOccupancySensorTypeBitmapWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeOccupancySensorTypeBitmapWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -2408,9 +2489,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -2431,41 +2512,40 @@ NS_ASSUME_NONNULL_BEGIN - (void)readAttributeOnOffWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeOnOffWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeOnOffWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeGlobalSceneControlWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeGlobalSceneControlWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeGlobalSceneControlWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeOnTimeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeOnTimeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeOnTimeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeOnTimeWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeOffWaitTimeWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeOffWaitTimeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeOffWaitTimeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeOffWaitTimeWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeStartUpOnOffWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeStartUpOnOffWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeStartUpOnOffWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeStartUpOnOffWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -2474,17 +2554,16 @@ NS_ASSUME_NONNULL_BEGIN NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeFeatureMapWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeFeatureMapWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -2498,18 +2577,17 @@ NS_ASSUME_NONNULL_BEGIN NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeSwitchTypeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeSwitchTypeWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeSwitchActionsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeSwitchActionsWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeSwitchActionsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeSwitchActionsWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -2518,9 +2596,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -2559,33 +2637,44 @@ NS_ASSUME_NONNULL_BEGIN - (void)readAttributeFabricsListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)subscribeAttributeFabricsListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeSupportedFabricsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeSupportedFabricsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeSupportedFabricsWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeCommissionedFabricsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeCommissionedFabricsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeCommissionedFabricsWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeTrustedRootCertificatesWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)subscribeAttributeTrustedRootCertificatesWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeCurrentFabricIndexWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeCurrentFabricIndexWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeCurrentFabricIndexWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -2594,9 +2683,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -2609,65 +2698,72 @@ NS_ASSUME_NONNULL_BEGIN - (void)readAttributeStatusWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeStatusWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeStatusWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeOrderWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeOrderWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeOrderWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeDescriptionWithCompletionHandler:(void (^)( NSString * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeDescriptionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeDescriptionWithResponseHandler:(void (^)( - NSString * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeBatteryVoltageWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeBatteryVoltageWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeBatteryVoltageWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeBatteryPercentRemainingWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeBatteryPercentRemainingWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeBatteryPercentRemainingWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeBatteryTimeRemainingWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeBatteryTimeRemainingWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeBatteryTimeRemainingWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeBatteryChargeLevelWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeBatteryChargeLevelWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeBatteryChargeLevelWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeActiveBatteryFaultsWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)subscribeAttributeActiveBatteryFaultsWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeBatteryChargeStateWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeBatteryChargeStateWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeBatteryChargeStateWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -2676,17 +2772,16 @@ NS_ASSUME_NONNULL_BEGIN NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeFeatureMapWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeFeatureMapWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -2716,25 +2811,25 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMeasuredValueWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeMinMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMinMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMinMeasuredValueWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeMaxMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMaxMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMaxMeasuredValueWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -2743,9 +2838,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -2759,140 +2854,140 @@ NS_ASSUME_NONNULL_BEGIN NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMaxPressureWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMaxPressureWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeMaxSpeedWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMaxSpeedWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMaxSpeedWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeMaxFlowWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMaxFlowWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMaxFlowWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeMinConstPressureWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMinConstPressureWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMinConstPressureWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeMaxConstPressureWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMaxConstPressureWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMaxConstPressureWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeMinCompPressureWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMinCompPressureWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMinCompPressureWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeMaxCompPressureWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMaxCompPressureWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMaxCompPressureWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeMinConstSpeedWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMinConstSpeedWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMinConstSpeedWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeMaxConstSpeedWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMaxConstSpeedWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMaxConstSpeedWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeMinConstFlowWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMinConstFlowWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMinConstFlowWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeMaxConstFlowWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMaxConstFlowWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMaxConstFlowWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeMinConstTempWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMinConstTempWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMinConstTempWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeMaxConstTempWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMaxConstTempWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMaxConstTempWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePumpStatusWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePumpStatusWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePumpStatusWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeEffectiveOperationModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeEffectiveOperationModeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeEffectiveOperationModeWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeEffectiveControlModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeEffectiveControlModeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeEffectiveControlModeWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeCapacityWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeCapacityWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeCapacityWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeSpeedWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeSpeedWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeSpeedWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeLifetimeRunningHoursWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; @@ -2900,15 +2995,16 @@ NS_ASSUME_NONNULL_BEGIN completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeLifetimeRunningHoursWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeLifetimeRunningHoursWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePowerWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePowerWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePowerWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeLifetimeEnergyConsumedWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; @@ -2916,35 +3012,34 @@ NS_ASSUME_NONNULL_BEGIN completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeLifetimeEnergyConsumedWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeLifetimeEnergyConsumedWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeOperationModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeOperationModeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeOperationModeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeOperationModeWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeControlModeWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeControlModeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeControlModeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeControlModeWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAlarmMaskWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeAlarmMaskWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeAlarmMaskWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -2953,17 +3048,16 @@ NS_ASSUME_NONNULL_BEGIN NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeFeatureMapWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeFeatureMapWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -2977,33 +3071,32 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMeasuredValueWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeMinMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMinMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMinMeasuredValueWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeMaxMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMaxMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMaxMeasuredValueWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeToleranceWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeToleranceWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeToleranceWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -3012,9 +3105,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -3048,41 +3141,38 @@ NS_ASSUME_NONNULL_BEGIN NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeSceneCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeSceneCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeCurrentSceneWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeCurrentSceneWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeCurrentSceneWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeCurrentGroupWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeCurrentGroupWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeCurrentGroupWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeSceneValidWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeSceneValidWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeSceneValidWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNameSupportWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeNameSupportWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNameSupportWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -3091,9 +3181,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -3107,30 +3197,36 @@ NS_ASSUME_NONNULL_BEGIN - (void)readAttributeThreadMetricsWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)subscribeAttributeThreadMetricsWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeCurrentHeapFreeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeCurrentHeapFreeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeCurrentHeapFreeWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeCurrentHeapUsedWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeCurrentHeapUsedWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeCurrentHeapUsedWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeCurrentHeapHighWatermarkWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeCurrentHeapHighWatermarkWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeCurrentHeapHighWatermarkWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -3142,9 +3238,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -3158,25 +3254,25 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeNumberOfPositionsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNumberOfPositionsWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeCurrentPositionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeCurrentPositionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeCurrentPositionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeMultiPressMaxWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMultiPressMaxWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMultiPressMaxWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -3185,17 +3281,16 @@ NS_ASSUME_NONNULL_BEGIN NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeFeatureMapWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeFeatureMapWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -3214,22 +3309,27 @@ NS_ASSUME_NONNULL_BEGIN - (void)readAttributeTvChannelListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)subscribeAttributeTvChannelListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeTvChannelLineupWithCompletionHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeTvChannelLineupWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeTvChannelLineupWithResponseHandler:(void (^)( - NSData * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeCurrentTvChannelWithCompletionHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeCurrentTvChannelWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeCurrentTvChannelWithResponseHandler:(void (^)( - NSData * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -3238,9 +3338,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -3256,6 +3356,12 @@ NS_ASSUME_NONNULL_BEGIN - (void)readAttributeTargetNavigatorListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)subscribeAttributeTargetNavigatorListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -3264,9 +3370,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -3280,33 +3386,32 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMeasuredValueWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeMinMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMinMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMinMeasuredValueWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeMaxMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMaxMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMaxMeasuredValueWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeToleranceWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeToleranceWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeToleranceWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -3315,9 +3420,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -3376,267 +3481,284 @@ NS_ASSUME_NONNULL_BEGIN - (void)writeAttributeBooleanWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeBooleanWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeBooleanWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeBitmap8WithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeBitmap8WithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeBitmap8WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeBitmap8WithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeBitmap16WithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeBitmap16WithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeBitmap16WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeBitmap16WithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeBitmap32WithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeBitmap32WithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeBitmap32WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeBitmap32WithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeBitmap64WithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeBitmap64WithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeBitmap64WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeBitmap64WithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeInt8uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeInt8uWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeInt8uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeInt8uWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeInt16uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeInt16uWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeInt16uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeInt16uWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeInt24uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeInt24uWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeInt24uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeInt24uWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeInt32uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeInt32uWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeInt32uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeInt32uWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeInt40uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeInt40uWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeInt40uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeInt40uWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeInt48uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeInt48uWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeInt48uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeInt48uWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeInt56uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeInt56uWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeInt56uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeInt56uWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeInt64uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeInt64uWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeInt64uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeInt64uWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeInt8sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeInt8sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeInt8sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeInt8sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeInt16sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeInt16sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeInt16sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeInt16sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeInt24sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeInt24sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeInt24sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeInt24sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeInt32sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeInt32sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeInt32sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeInt32sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeInt40sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeInt40sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeInt40sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeInt40sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeInt48sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeInt48sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeInt48sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeInt48sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeInt56sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeInt56sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeInt56sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeInt56sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeInt64sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeInt64sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeInt64sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeInt64sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeEnum8WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeEnum8WithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeEnum8WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeEnum8WithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeEnum16WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeEnum16WithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeEnum16WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeEnum16WithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeFloatSingleWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeFloatSingleWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeFloatSingleWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeFloatSingleWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeFloatDoubleWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeFloatDoubleWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeFloatDoubleWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeFloatDoubleWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeOctetStringWithCompletionHandler:(void (^)( NSData * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeOctetStringWithValue:(NSData * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeOctetStringWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeOctetStringWithResponseHandler:(void (^)( - NSData * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeListInt8uWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeListInt8uWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; +- (void)subscribeAttributeListInt8uWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeListOctetStringWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeListOctetStringWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; +- (void)subscribeAttributeListOctetStringWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeListStructOctetStringWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeListStructOctetStringWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; +- (void)subscribeAttributeListStructOctetStringWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeLongOctetStringWithCompletionHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeLongOctetStringWithValue:(NSData * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeLongOctetStringWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeLongOctetStringWithResponseHandler:(void (^)( - NSData * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeCharStringWithCompletionHandler:(void (^)( NSString * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeCharStringWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeCharStringWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeCharStringWithResponseHandler:(void (^)( - NSString * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeLongCharStringWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeLongCharStringWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeLongCharStringWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeLongCharStringWithResponseHandler:(void (^)( - NSString * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeEpochUsWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeEpochUsWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeEpochUsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeEpochUsWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeEpochSWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeEpochSWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeEpochSWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeEpochSWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeVendorIdWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeVendorIdWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeVendorIdWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeVendorIdWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeListNullablesAndOptionalsStructWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)subscribeAttributeListNullablesAndOptionalsStructWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeEnumAttrWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeEnumAttrWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeEnumAttrWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeEnumAttrWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeRangeRestrictedInt8uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; @@ -3644,9 +3766,10 @@ NS_ASSUME_NONNULL_BEGIN completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeRangeRestrictedInt8uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeRangeRestrictedInt8uWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeRangeRestrictedInt8sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; @@ -3654,9 +3777,10 @@ NS_ASSUME_NONNULL_BEGIN completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeRangeRestrictedInt8sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeRangeRestrictedInt8sWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeRangeRestrictedInt16uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; @@ -3664,9 +3788,10 @@ NS_ASSUME_NONNULL_BEGIN completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeRangeRestrictedInt16uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeRangeRestrictedInt16uWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeRangeRestrictedInt16sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; @@ -3674,9 +3799,10 @@ NS_ASSUME_NONNULL_BEGIN completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeRangeRestrictedInt16sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeRangeRestrictedInt16sWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeListLongOctetStringWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -3690,216 +3816,215 @@ NS_ASSUME_NONNULL_BEGIN - (void)writeAttributeUnsupportedWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeUnsupportedWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeUnsupportedWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNullableBooleanWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeNullableBooleanWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeNullableBooleanWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNullableBooleanWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNullableBitmap8WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeNullableBitmap8WithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeNullableBitmap8WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNullableBitmap8WithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNullableBitmap16WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeNullableBitmap16WithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeNullableBitmap16WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNullableBitmap16WithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNullableBitmap32WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeNullableBitmap32WithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeNullableBitmap32WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNullableBitmap32WithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNullableBitmap64WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeNullableBitmap64WithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeNullableBitmap64WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNullableBitmap64WithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNullableInt8uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeNullableInt8uWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeNullableInt8uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNullableInt8uWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNullableInt16uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeNullableInt16uWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeNullableInt16uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNullableInt16uWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNullableInt24uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeNullableInt24uWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeNullableInt24uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNullableInt24uWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNullableInt32uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeNullableInt32uWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeNullableInt32uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNullableInt32uWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNullableInt40uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeNullableInt40uWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeNullableInt40uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNullableInt40uWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNullableInt48uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeNullableInt48uWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeNullableInt48uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNullableInt48uWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNullableInt56uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeNullableInt56uWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeNullableInt56uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNullableInt56uWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNullableInt64uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeNullableInt64uWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeNullableInt64uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNullableInt64uWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNullableInt8sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeNullableInt8sWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeNullableInt8sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNullableInt8sWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNullableInt16sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeNullableInt16sWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeNullableInt16sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNullableInt16sWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNullableInt24sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeNullableInt24sWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeNullableInt24sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNullableInt24sWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNullableInt32sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeNullableInt32sWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeNullableInt32sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNullableInt32sWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNullableInt40sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeNullableInt40sWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeNullableInt40sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNullableInt40sWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNullableInt48sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeNullableInt48sWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeNullableInt48sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNullableInt48sWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNullableInt56sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeNullableInt56sWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeNullableInt56sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNullableInt56sWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNullableInt64sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeNullableInt64sWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeNullableInt64sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNullableInt64sWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNullableEnum8WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeNullableEnum8WithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeNullableEnum8WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNullableEnum8WithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNullableEnum16WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeNullableEnum16WithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeNullableEnum16WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNullableEnum16WithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNullableFloatSingleWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; @@ -3907,9 +4032,10 @@ NS_ASSUME_NONNULL_BEGIN completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeNullableFloatSingleWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNullableFloatSingleWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNullableFloatDoubleWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; @@ -3917,36 +4043,38 @@ NS_ASSUME_NONNULL_BEGIN completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeNullableFloatDoubleWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNullableFloatDoubleWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNullableOctetStringWithCompletionHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeNullableOctetStringWithValue:(NSData * _Nullable)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeNullableOctetStringWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNullableOctetStringWithResponseHandler:(void (^)(NSData * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNullableCharStringWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeNullableCharStringWithValue:(NSString * _Nullable)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeNullableCharStringWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNullableCharStringWithResponseHandler:(void (^)(NSString * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNullableEnumAttrWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeNullableEnumAttrWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeNullableEnumAttrWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNullableEnumAttrWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNullableRangeRestrictedInt8uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; @@ -3954,9 +4082,10 @@ NS_ASSUME_NONNULL_BEGIN completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeNullableRangeRestrictedInt8uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNullableRangeRestrictedInt8uWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeNullableRangeRestrictedInt8sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; @@ -3964,9 +4093,10 @@ NS_ASSUME_NONNULL_BEGIN completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeNullableRangeRestrictedInt8sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNullableRangeRestrictedInt8sWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeNullableRangeRestrictedInt16uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; @@ -3974,9 +4104,10 @@ NS_ASSUME_NONNULL_BEGIN completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeNullableRangeRestrictedInt16uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNullableRangeRestrictedInt16uWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeNullableRangeRestrictedInt16sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; @@ -3984,9 +4115,10 @@ NS_ASSUME_NONNULL_BEGIN completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeNullableRangeRestrictedInt16sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNullableRangeRestrictedInt16sWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -3995,9 +4127,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -4020,41 +4152,45 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeLocalTemperatureWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeLocalTemperatureWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAbsMinHeatSetpointLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeAbsMinHeatSetpointLimitWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeAbsMinHeatSetpointLimitWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeAbsMaxHeatSetpointLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeAbsMaxHeatSetpointLimitWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeAbsMaxHeatSetpointLimitWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeAbsMinCoolSetpointLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeAbsMinCoolSetpointLimitWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeAbsMinCoolSetpointLimitWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeAbsMaxCoolSetpointLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeAbsMaxCoolSetpointLimitWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeAbsMaxCoolSetpointLimitWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeOccupiedCoolingSetpointWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; @@ -4062,9 +4198,10 @@ NS_ASSUME_NONNULL_BEGIN completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeOccupiedCoolingSetpointWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeOccupiedCoolingSetpointWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeOccupiedHeatingSetpointWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; @@ -4072,9 +4209,10 @@ NS_ASSUME_NONNULL_BEGIN completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeOccupiedHeatingSetpointWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeOccupiedHeatingSetpointWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeMinHeatSetpointLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; @@ -4082,9 +4220,10 @@ NS_ASSUME_NONNULL_BEGIN completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeMinHeatSetpointLimitWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMinHeatSetpointLimitWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeMaxHeatSetpointLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; @@ -4092,9 +4231,10 @@ NS_ASSUME_NONNULL_BEGIN completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeMaxHeatSetpointLimitWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMaxHeatSetpointLimitWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeMinCoolSetpointLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; @@ -4102,9 +4242,10 @@ NS_ASSUME_NONNULL_BEGIN completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeMinCoolSetpointLimitWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMinCoolSetpointLimitWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeMaxCoolSetpointLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; @@ -4112,18 +4253,20 @@ NS_ASSUME_NONNULL_BEGIN completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeMaxCoolSetpointLimitWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMaxCoolSetpointLimitWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeMinSetpointDeadBandWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeMinSetpointDeadBandWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeMinSetpointDeadBandWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMinSetpointDeadBandWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeControlSequenceOfOperationWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; @@ -4131,42 +4274,43 @@ NS_ASSUME_NONNULL_BEGIN completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeControlSequenceOfOperationWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeControlSequenceOfOperationWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeSystemModeWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeSystemModeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeSystemModeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeSystemModeWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeStartOfWeekWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeStartOfWeekWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeStartOfWeekWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNumberOfWeeklyTransitionsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeNumberOfWeeklyTransitionsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNumberOfWeeklyTransitionsWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeNumberOfDailyTransitionsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeNumberOfDailyTransitionsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNumberOfDailyTransitionsWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -4175,17 +4319,16 @@ NS_ASSUME_NONNULL_BEGIN NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeFeatureMapWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeFeatureMapWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -4201,18 +4344,19 @@ NS_ASSUME_NONNULL_BEGIN completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeTemperatureDisplayModeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeTemperatureDisplayModeWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeKeypadLockoutWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeKeypadLockoutWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeKeypadLockoutWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeKeypadLockoutWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeScheduleProgrammingVisibilityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; @@ -4220,9 +4364,10 @@ NS_ASSUME_NONNULL_BEGIN completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeScheduleProgrammingVisibilityWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeScheduleProgrammingVisibilityWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -4231,9 +4376,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -4249,475 +4394,507 @@ NS_ASSUME_NONNULL_BEGIN NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeChannelWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeChannelWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeRoutingRoleWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeRoutingRoleWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeRoutingRoleWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNetworkNameWithCompletionHandler:(void (^)( NSData * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeNetworkNameWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeNetworkNameWithResponseHandler:(void (^)( - NSData * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePanIdWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePanIdWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePanIdWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeExtendedPanIdWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeExtendedPanIdWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeExtendedPanIdWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeMeshLocalPrefixWithCompletionHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeMeshLocalPrefixWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeMeshLocalPrefixWithResponseHandler:(void (^)( - NSData * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeOverrunCountWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeOverrunCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeOverrunCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeNeighborTableListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)subscribeAttributeNeighborTableListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeRouteTableListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)subscribeAttributeRouteTableListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePartitionIdWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePartitionIdWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePartitionIdWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeWeightingWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeWeightingWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeWeightingWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeDataVersionWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeDataVersionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeDataVersionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeStableDataVersionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeStableDataVersionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeStableDataVersionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeLeaderRouterIdWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeLeaderRouterIdWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeLeaderRouterIdWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeDetachedRoleCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeDetachedRoleCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeDetachedRoleCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeChildRoleCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeChildRoleCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeChildRoleCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeRouterRoleCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeRouterRoleCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeRouterRoleCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeLeaderRoleCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeLeaderRoleCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeLeaderRoleCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttachAttemptCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeAttachAttemptCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeAttachAttemptCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePartitionIdChangeCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePartitionIdChangeCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePartitionIdChangeCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeBetterPartitionAttachAttemptCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeBetterPartitionAttachAttemptCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeBetterPartitionAttachAttemptCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeParentChangeCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeParentChangeCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeParentChangeCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeTxTotalCountWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeTxTotalCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeTxTotalCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeTxUnicastCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeTxUnicastCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeTxUnicastCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeTxBroadcastCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeTxBroadcastCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeTxBroadcastCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeTxAckRequestedCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeTxAckRequestedCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeTxAckRequestedCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeTxAckedCountWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeTxAckedCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeTxAckedCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeTxNoAckRequestedCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeTxNoAckRequestedCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeTxNoAckRequestedCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeTxDataCountWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeTxDataCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeTxDataCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeTxDataPollCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeTxDataPollCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeTxDataPollCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeTxBeaconCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeTxBeaconCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeTxBeaconCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeTxBeaconRequestCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeTxBeaconRequestCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeTxBeaconRequestCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeTxOtherCountWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeTxOtherCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeTxOtherCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeTxRetryCountWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeTxRetryCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeTxRetryCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeTxDirectMaxRetryExpiryCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeTxDirectMaxRetryExpiryCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeTxDirectMaxRetryExpiryCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeTxIndirectMaxRetryExpiryCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeTxIndirectMaxRetryExpiryCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeTxIndirectMaxRetryExpiryCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeTxErrCcaCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeTxErrCcaCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeTxErrCcaCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeTxErrAbortCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeTxErrAbortCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeTxErrAbortCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeTxErrBusyChannelCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeTxErrBusyChannelCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeTxErrBusyChannelCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeRxTotalCountWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeRxTotalCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeRxTotalCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeRxUnicastCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeRxUnicastCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeRxUnicastCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeRxBroadcastCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeRxBroadcastCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeRxBroadcastCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeRxDataCountWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeRxDataCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeRxDataCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeRxDataPollCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeRxDataPollCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeRxDataPollCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeRxBeaconCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeRxBeaconCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeRxBeaconCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeRxBeaconRequestCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeRxBeaconRequestCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeRxBeaconRequestCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeRxOtherCountWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeRxOtherCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeRxOtherCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeRxAddressFilteredCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeRxAddressFilteredCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeRxAddressFilteredCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeRxDestAddrFilteredCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeRxDestAddrFilteredCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeRxDestAddrFilteredCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeRxDuplicatedCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeRxDuplicatedCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeRxDuplicatedCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeRxErrNoFrameCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeRxErrNoFrameCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeRxErrNoFrameCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeRxErrUnknownNeighborCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeRxErrUnknownNeighborCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeRxErrUnknownNeighborCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeRxErrInvalidSrcAddrCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeRxErrInvalidSrcAddrCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeRxErrInvalidSrcAddrCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeRxErrSecCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeRxErrSecCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeRxErrSecCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeRxErrFcsCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeRxErrFcsCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeRxErrFcsCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeRxErrOtherCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeRxErrOtherCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeRxErrOtherCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeActiveTimestampWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeActiveTimestampWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeActiveTimestampWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePendingTimestampWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePendingTimestampWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePendingTimestampWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeDelayWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeDelayWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeDelayWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeSecurityPolicyWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)subscribeAttributeSecurityPolicyWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeChannelMaskWithCompletionHandler:(void (^)( NSData * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeChannelMaskWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeChannelMaskWithResponseHandler:(void (^)( - NSData * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeOperationalDatasetComponentsWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)subscribeAttributeOperationalDatasetComponentsWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeActiveNetworkFaultsListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)subscribeAttributeActiveNetworkFaultsListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -4729,9 +4906,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -4745,9 +4922,10 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeWakeOnLanMacAddressWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeWakeOnLanMacAddressWithResponseHandler:(void (^)(NSString * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -4756,9 +4934,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -4773,102 +4951,105 @@ NS_ASSUME_NONNULL_BEGIN - (void)readAttributeBssidWithCompletionHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeBssidWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeBssidWithResponseHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeSecurityTypeWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeSecurityTypeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeSecurityTypeWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeWiFiVersionWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeWiFiVersionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeWiFiVersionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeChannelNumberWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeChannelNumberWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeChannelNumberWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeRssiWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeRssiWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeRssiWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeBeaconLostCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeBeaconLostCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeBeaconLostCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeBeaconRxCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeBeaconRxCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeBeaconRxCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePacketMulticastRxCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePacketMulticastRxCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePacketMulticastRxCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributePacketMulticastTxCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePacketMulticastTxCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePacketMulticastTxCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributePacketUnicastRxCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePacketUnicastRxCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePacketUnicastRxCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributePacketUnicastTxCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributePacketUnicastTxCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributePacketUnicastTxCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeCurrentMaxRateWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeCurrentMaxRateWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeCurrentMaxRateWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeOverrunCountWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeOverrunCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeOverrunCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -4880,9 +5061,9 @@ NS_ASSUME_NONNULL_BEGIN NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end @@ -4907,143 +5088,155 @@ NS_ASSUME_NONNULL_BEGIN - (void)readAttributeTypeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeTypeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeTypeWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeCurrentPositionLiftWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeCurrentPositionLiftWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeCurrentPositionLiftWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeCurrentPositionTiltWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeCurrentPositionTiltWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeCurrentPositionTiltWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeConfigStatusWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeConfigStatusWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeConfigStatusWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeCurrentPositionLiftPercentageWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeCurrentPositionLiftPercentageWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeCurrentPositionLiftPercentageWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeCurrentPositionTiltPercentageWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeCurrentPositionTiltPercentageWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeCurrentPositionTiltPercentageWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeOperationalStatusWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeOperationalStatusWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeOperationalStatusWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeTargetPositionLiftPercent100thsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeTargetPositionLiftPercent100thsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeTargetPositionLiftPercent100thsWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeTargetPositionTiltPercent100thsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeTargetPositionTiltPercent100thsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeTargetPositionTiltPercent100thsWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeEndProductTypeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeEndProductTypeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeEndProductTypeWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeCurrentPositionLiftPercent100thsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeCurrentPositionLiftPercent100thsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeCurrentPositionLiftPercent100thsWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeCurrentPositionTiltPercent100thsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeCurrentPositionTiltPercent100thsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeCurrentPositionTiltPercent100thsWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeInstalledOpenLimitLiftWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeInstalledOpenLimitLiftWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeInstalledOpenLimitLiftWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeInstalledClosedLimitLiftWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeInstalledClosedLimitLiftWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeInstalledClosedLimitLiftWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeInstalledOpenLimitTiltWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeInstalledOpenLimitTiltWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeInstalledOpenLimitTiltWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeInstalledClosedLimitTiltWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeInstalledClosedLimitTiltWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeInstalledClosedLimitTiltWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler; - (void)readAttributeModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeModeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeModeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeModeWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeSafetyStatusWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeSafetyStatusWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeSafetyStatusWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler; @@ -5052,17 +5245,16 @@ NS_ASSUME_NONNULL_BEGIN NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeFeatureMapWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeFeatureMapWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler; -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler; + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler; @end diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm index a27813dc27700e..1ccc5f958a4279 100644 --- a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm +++ b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm @@ -44,11 +44,7 @@ @implementation CHIPAccessControl - (void)readAttributeAclWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPAccessControlAclListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = AccessControl::Attributes::Acl::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -60,7 +56,7 @@ - (void)writeAttributeAclWithValue:(NSArray * _Nonnull)value completionHandler:( { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -172,15 +168,28 @@ new CHIPDefaultSuccessCallbackBridge( }); } +- (void)subscribeAttributeAclWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + new CHIPAccessControlAclListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = AccessControl::Attributes::Acl::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPAccessControlAclListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); +} + - (void)readAttributeExtensionWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPAccessControlExtensionListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = AccessControl::Attributes::Extension::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -192,7 +201,7 @@ - (void)writeAttributeExtensionWithValue:(NSArray * _Nonnull)value completionHan { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -228,15 +237,29 @@ new CHIPDefaultSuccessCallbackBridge( }); } +- (void)subscribeAttributeExtensionWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + new CHIPAccessControlExtensionListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = AccessControl::Attributes::Extension::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPAccessControlExtensionListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); +} + - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPAccessControlAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = AccessControl::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -247,17 +270,12 @@ new CHIPAccessControlAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = AccessControl::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = AccessControl::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } @end @@ -278,11 +296,7 @@ - (void)getSetupPINWithParams:(CHIPAccountLoginClusterGetSetupPINParams *)params request.tempAccountIdentifier = [self asCharSpan:params.tempAccountIdentifier]; new CHIPAccountLoginClusterGetSetupPINResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -298,7 +312,7 @@ - (void)loginWithParams:(CHIPAccountLoginClusterLoginParams *)params completionH new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -312,11 +326,7 @@ - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPAccountLoginAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = AccountLogin::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -327,40 +337,30 @@ new CHIPAccountLoginAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = AccountLogin::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = AccountLogin::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = AccountLogin::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -381,7 +381,7 @@ - (void)openBasicCommissioningWindowWithParams:(CHIPAdministratorCommissioningCl new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -405,7 +405,7 @@ - (void)openCommissioningWindowWithParams:(CHIPAdministratorCommissioningCluster new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -422,7 +422,7 @@ - (void)revokeCommissioningWithCompletionHandler:(StatusCompletion)completionHan new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -435,60 +435,41 @@ new CHIPCommandSuccessCallbackBridge( - (void)readAttributeWindowStatusWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = AdministratorCommissioning::Attributes::WindowStatus::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = AdministratorCommissioning::Attributes::WindowStatus::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)readAttributeAdminFabricIndexWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = AdministratorCommissioning::Attributes::AdminFabricIndex::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = AdministratorCommissioning::Attributes::AdminFabricIndex::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)readAttributeAdminVendorIdWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = AdministratorCommissioning::Attributes::AdminVendorId::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = AdministratorCommissioning::Attributes::AdminVendorId::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPAdministratorCommissioningAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = AdministratorCommissioning::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -499,40 +480,30 @@ new CHIPAdministratorCommissioningAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = AdministratorCommissioning::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = AdministratorCommissioning::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = AdministratorCommissioning::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -553,7 +524,7 @@ - (void)changeStatusWithParams:(CHIPApplicationBasicClusterChangeStatusParams *) new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -566,283 +537,208 @@ new CHIPCommandSuccessCallbackBridge( - (void)readAttributeVendorNameWithCompletionHandler:(void (^)( NSString * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ApplicationBasic::Attributes::VendorName::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ApplicationBasic::Attributes::VendorName::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeVendorNameWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeVendorName(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeVendorNameWithResponseHandler:(void (^)( - NSString * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPCharStringAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeVendorName(success); + using TypeInfo = ApplicationBasic::Attributes::VendorName::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeVendorIdWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ApplicationBasic::Attributes::VendorId::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ApplicationBasic::Attributes::VendorId::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeVendorIdWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeVendorId(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeVendorIdWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeVendorId(success); + using TypeInfo = ApplicationBasic::Attributes::VendorId::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeApplicationNameWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ApplicationBasic::Attributes::ApplicationName::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ApplicationBasic::Attributes::ApplicationName::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeApplicationNameWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeApplicationName(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeApplicationNameWithResponseHandler:(void (^)( - NSString * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPCharStringAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeApplicationName(success); + using TypeInfo = ApplicationBasic::Attributes::ApplicationName::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeProductIdWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ApplicationBasic::Attributes::ProductId::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ApplicationBasic::Attributes::ProductId::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeProductIdWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeProductId(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeProductIdWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeProductId(success); + using TypeInfo = ApplicationBasic::Attributes::ProductId::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeApplicationIdWithCompletionHandler:(void (^)( NSString * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ApplicationBasic::Attributes::ApplicationId::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ApplicationBasic::Attributes::ApplicationId::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeApplicationIdWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeApplicationId(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeApplicationIdWithResponseHandler:(void (^)( - NSString * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPCharStringAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeApplicationId(success); + using TypeInfo = ApplicationBasic::Attributes::ApplicationId::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeCatalogVendorIdWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ApplicationBasic::Attributes::CatalogVendorId::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ApplicationBasic::Attributes::CatalogVendorId::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeCatalogVendorIdWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCatalogVendorId(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeCatalogVendorIdWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCatalogVendorId(success); + using TypeInfo = ApplicationBasic::Attributes::CatalogVendorId::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeApplicationStatusWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ApplicationBasic::Attributes::ApplicationStatus::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ApplicationBasic::Attributes::ApplicationStatus::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeApplicationStatusWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeApplicationStatus(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeApplicationStatusWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeApplicationStatus(success); + using TypeInfo = ApplicationBasic::Attributes::ApplicationStatus::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPApplicationBasicAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = ApplicationBasic::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -853,40 +749,30 @@ new CHIPApplicationBasicAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ApplicationBasic::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ApplicationBasic::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = ApplicationBasic::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -909,11 +795,7 @@ - (void)launchAppWithParams:(CHIPApplicationLauncherClusterLaunchAppParams *)par request.applicationId = [self asCharSpan:params.applicationId]; new CHIPApplicationLauncherClusterLaunchAppResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -924,11 +806,7 @@ - (void)readAttributeApplicationLauncherListWithCompletionHandler:(void (^)(NSAr NSError * _Nullable error))completionHandler { new CHIPApplicationLauncherApplicationLauncherListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = ApplicationLauncher::Attributes::ApplicationLauncherList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -936,93 +814,89 @@ new CHIPApplicationLauncherApplicationLauncherListListAttributeCallbackBridge( }); } -- (void)readAttributeCatalogVendorIdWithCompletionHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))completionHandler +- (void)subscribeAttributeApplicationLauncherListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, + new CHIPApplicationLauncherApplicationLauncherListListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ApplicationLauncher::Attributes::CatalogVendorId::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = ApplicationLauncher::Attributes::ApplicationLauncherList::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPApplicationLauncherApplicationLauncherListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); } -- (void)subscribeAttributeCatalogVendorIdWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)readAttributeCatalogVendorIdWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCatalogVendorId(success, failure, minInterval, maxInterval); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ApplicationLauncher::Attributes::CatalogVendorId::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)reportAttributeCatalogVendorIdWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +- (void)subscribeAttributeCatalogVendorIdWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCatalogVendorId(success); + using TypeInfo = ApplicationLauncher::Attributes::CatalogVendorId::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeApplicationIdWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ApplicationLauncher::Attributes::ApplicationId::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ApplicationLauncher::Attributes::ApplicationId::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeApplicationIdWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeApplicationId(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeApplicationIdWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeApplicationId(success); + using TypeInfo = ApplicationLauncher::Attributes::ApplicationId::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPApplicationLauncherAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = ApplicationLauncher::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -1033,40 +907,30 @@ new CHIPApplicationLauncherAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ApplicationLauncher::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ApplicationLauncher::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = ApplicationLauncher::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -1088,7 +952,7 @@ - (void)renameOutputWithParams:(CHIPAudioOutputClusterRenameOutputParams *)param new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1107,7 +971,7 @@ - (void)selectOutputWithParams:(CHIPAudioOutputClusterSelectOutputParams *)param new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1121,11 +985,7 @@ - (void)readAttributeAudioOutputListWithCompletionHandler:(void (^)(NSArray * _N NSError * _Nullable error))completionHandler { new CHIPAudioOutputAudioOutputListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = AudioOutput::Attributes::AudioOutputList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -1133,54 +993,59 @@ new CHIPAudioOutputAudioOutputListListAttributeCallbackBridge( }); } -- (void)readAttributeCurrentAudioOutputWithCompletionHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))completionHandler +- (void)subscribeAttributeAudioOutputListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, + new CHIPAudioOutputAudioOutputListListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = AudioOutput::Attributes::CurrentAudioOutput::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = AudioOutput::Attributes::AudioOutputList::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPAudioOutputAudioOutputListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); } -- (void)subscribeAttributeCurrentAudioOutputWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)readAttributeCurrentAudioOutputWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCurrentAudioOutput(success, failure, minInterval, maxInterval); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = AudioOutput::Attributes::CurrentAudioOutput::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)reportAttributeCurrentAudioOutputWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler +- (void)subscribeAttributeCurrentAudioOutputWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCurrentAudioOutput(success); + using TypeInfo = AudioOutput::Attributes::CurrentAudioOutput::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPAudioOutputAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = AudioOutput::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -1191,40 +1056,30 @@ new CHIPAudioOutputAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = AudioOutput::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = AudioOutput::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = AudioOutput::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -1245,7 +1100,7 @@ - (void)barrierControlGoToPercentWithParams:(CHIPBarrierControlClusterBarrierCon new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1262,7 +1117,7 @@ - (void)barrierControlStopWithCompletionHandler:(StatusCompletion)completionHand new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1275,168 +1130,126 @@ new CHIPCommandSuccessCallbackBridge( - (void)readAttributeBarrierMovingStateWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = BarrierControl::Attributes::BarrierMovingState::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = BarrierControl::Attributes::BarrierMovingState::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeBarrierMovingStateWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeBarrierMovingState(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeBarrierMovingStateWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeBarrierMovingState(success); + using TypeInfo = BarrierControl::Attributes::BarrierMovingState::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeBarrierSafetyStatusWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = BarrierControl::Attributes::BarrierSafetyStatus::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = BarrierControl::Attributes::BarrierSafetyStatus::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeBarrierSafetyStatusWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeBarrierSafetyStatus(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeBarrierSafetyStatusWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler -{ - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeBarrierSafetyStatus(success); + using TypeInfo = BarrierControl::Attributes::BarrierSafetyStatus::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeBarrierCapabilitiesWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = BarrierControl::Attributes::BarrierCapabilities::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = BarrierControl::Attributes::BarrierCapabilities::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeBarrierCapabilitiesWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeBarrierCapabilities(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeBarrierCapabilitiesWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeBarrierCapabilities(success); + using TypeInfo = BarrierControl::Attributes::BarrierCapabilities::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeBarrierPositionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = BarrierControl::Attributes::BarrierPosition::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = BarrierControl::Attributes::BarrierPosition::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeBarrierPositionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeBarrierPosition(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeBarrierPositionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeBarrierPosition(success); + using TypeInfo = BarrierControl::Attributes::BarrierPosition::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPBarrierControlAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = BarrierControl::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -1447,40 +1260,30 @@ new CHIPBarrierControlAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = BarrierControl::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = BarrierControl::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = BarrierControl::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -1499,7 +1302,7 @@ - (void)mfgSpecificPingWithCompletionHandler:(StatusCompletion)completionHandler new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1512,217 +1315,161 @@ new CHIPCommandSuccessCallbackBridge( - (void)readAttributeInteractionModelVersionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Basic::Attributes::InteractionModelVersion::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Basic::Attributes::InteractionModelVersion::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeInteractionModelVersionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeInteractionModelVersion(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeInteractionModelVersionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeInteractionModelVersion(success); + using TypeInfo = Basic::Attributes::InteractionModelVersion::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeVendorNameWithCompletionHandler:(void (^)( NSString * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Basic::Attributes::VendorName::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Basic::Attributes::VendorName::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeVendorNameWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeVendorName(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeVendorNameWithResponseHandler:(void (^)( - NSString * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPCharStringAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeVendorName(success); + using TypeInfo = Basic::Attributes::VendorName::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeVendorIDWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Basic::Attributes::VendorID::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Basic::Attributes::VendorID::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeVendorIDWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeVendorID(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeVendorIDWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeVendorID(success); + using TypeInfo = Basic::Attributes::VendorID::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeProductNameWithCompletionHandler:(void (^)( NSString * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Basic::Attributes::ProductName::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Basic::Attributes::ProductName::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeProductNameWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeProductName(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeProductNameWithResponseHandler:(void (^)( - NSString * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPCharStringAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeProductName(success); + using TypeInfo = Basic::Attributes::ProductName::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeProductIDWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Basic::Attributes::ProductID::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Basic::Attributes::ProductID::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeProductIDWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeProductID(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeProductIDWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeProductID(success); + using TypeInfo = Basic::Attributes::ProductID::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNodeLabelWithCompletionHandler:(void (^)( NSString * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Basic::Attributes::NodeLabel::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Basic::Attributes::NodeLabel::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeNodeLabelWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1738,47 +1485,37 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeNodeLabelWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNodeLabel(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNodeLabelWithResponseHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPCharStringAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNodeLabel(success); + using TypeInfo = Basic::Attributes::NodeLabel::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeLocationWithCompletionHandler:(void (^)( NSString * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Basic::Attributes::Location::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Basic::Attributes::Location::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeLocationWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1794,398 +1531,296 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeLocationWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeLocation(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeLocationWithResponseHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPCharStringAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeLocation(success); + using TypeInfo = Basic::Attributes::Location::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeHardwareVersionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Basic::Attributes::HardwareVersion::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Basic::Attributes::HardwareVersion::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeHardwareVersionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeHardwareVersion(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeHardwareVersionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeHardwareVersion(success); + using TypeInfo = Basic::Attributes::HardwareVersion::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeHardwareVersionStringWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Basic::Attributes::HardwareVersionString::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Basic::Attributes::HardwareVersionString::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeHardwareVersionStringWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeHardwareVersionString(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeHardwareVersionStringWithResponseHandler:(void (^)(NSString * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPCharStringAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeHardwareVersionString(success); + using TypeInfo = Basic::Attributes::HardwareVersionString::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeSoftwareVersionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Basic::Attributes::SoftwareVersion::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Basic::Attributes::SoftwareVersion::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeSoftwareVersionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeSoftwareVersion(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeSoftwareVersionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeSoftwareVersion(success); + using TypeInfo = Basic::Attributes::SoftwareVersion::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeSoftwareVersionStringWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Basic::Attributes::SoftwareVersionString::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Basic::Attributes::SoftwareVersionString::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeSoftwareVersionStringWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeSoftwareVersionString(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeSoftwareVersionStringWithResponseHandler:(void (^)(NSString * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPCharStringAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeSoftwareVersionString(success); + using TypeInfo = Basic::Attributes::SoftwareVersionString::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeManufacturingDateWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Basic::Attributes::ManufacturingDate::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Basic::Attributes::ManufacturingDate::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeManufacturingDateWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeManufacturingDate(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeManufacturingDateWithResponseHandler:(void (^)(NSString * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPCharStringAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeManufacturingDate(success); + using TypeInfo = Basic::Attributes::ManufacturingDate::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributePartNumberWithCompletionHandler:(void (^)( NSString * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Basic::Attributes::PartNumber::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Basic::Attributes::PartNumber::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributePartNumberWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePartNumber(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributePartNumberWithResponseHandler:(void (^)( - NSString * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPCharStringAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePartNumber(success); + using TypeInfo = Basic::Attributes::PartNumber::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeProductURLWithCompletionHandler:(void (^)( NSString * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Basic::Attributes::ProductURL::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Basic::Attributes::ProductURL::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeProductURLWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeProductURL(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeProductURLWithResponseHandler:(void (^)( - NSString * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPCharStringAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeProductURL(success); + using TypeInfo = Basic::Attributes::ProductURL::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeProductLabelWithCompletionHandler:(void (^)( NSString * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Basic::Attributes::ProductLabel::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Basic::Attributes::ProductLabel::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeProductLabelWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeProductLabel(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeProductLabelWithResponseHandler:(void (^)( - NSString * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPCharStringAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeProductLabel(success); + using TypeInfo = Basic::Attributes::ProductLabel::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeSerialNumberWithCompletionHandler:(void (^)( NSString * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Basic::Attributes::SerialNumber::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Basic::Attributes::SerialNumber::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeSerialNumberWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeSerialNumber(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeSerialNumberWithResponseHandler:(void (^)( - NSString * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPCharStringAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeSerialNumber(success); + using TypeInfo = Basic::Attributes::SerialNumber::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeLocalConfigDisabledWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPBooleanAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Basic::Attributes::LocalConfigDisabled::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Basic::Attributes::LocalConfigDisabled::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeLocalConfigDisabledWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2201,90 +1836,67 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeLocalConfigDisabledWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeLocalConfigDisabled(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeLocalConfigDisabledWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPBooleanAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPBooleanAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeLocalConfigDisabled(success); + using TypeInfo = Basic::Attributes::LocalConfigDisabled::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeReachableWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPBooleanAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Basic::Attributes::Reachable::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Basic::Attributes::Reachable::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeReachableWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeReachable(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeReachableWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPBooleanAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPBooleanAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeReachable(success); + using TypeInfo = Basic::Attributes::Reachable::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeUniqueIDWithCompletionHandler:(void (^)( NSString * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Basic::Attributes::UniqueID::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Basic::Attributes::UniqueID::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPBasicAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = Basic::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -2295,40 +1907,30 @@ new CHIPBasicAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Basic::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Basic::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = Basic::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -2343,24 +1945,19 @@ @implementation CHIPBinaryInputBasic - (void)readAttributeOutOfServiceWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPBooleanAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = BinaryInputBasic::Attributes::OutOfService::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = BinaryInputBasic::Attributes::OutOfService::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeOutOfServiceWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2376,48 +1973,37 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeOutOfServiceWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeOutOfService(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeOutOfServiceWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPBooleanAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPBooleanAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeOutOfService(success); + using TypeInfo = BinaryInputBasic::Attributes::OutOfService::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributePresentValueWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPBooleanAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = BinaryInputBasic::Attributes::PresentValue::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = BinaryInputBasic::Attributes::PresentValue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributePresentValueWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2433,75 +2019,54 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributePresentValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePresentValue(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributePresentValueWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPBooleanAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPBooleanAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePresentValue(success); + using TypeInfo = BinaryInputBasic::Attributes::PresentValue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeStatusFlagsWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = BinaryInputBasic::Attributes::StatusFlags::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = BinaryInputBasic::Attributes::StatusFlags::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeStatusFlagsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeStatusFlags(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeStatusFlagsWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeStatusFlags(success); + using TypeInfo = BinaryInputBasic::Attributes::StatusFlags::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPBinaryInputBasicAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = BinaryInputBasic::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -2512,40 +2077,30 @@ new CHIPBinaryInputBasicAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = BinaryInputBasic::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = BinaryInputBasic::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = BinaryInputBasic::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -2568,7 +2123,7 @@ - (void)bindWithParams:(CHIPBindingClusterBindParams *)params completionHandler: new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2589,7 +2144,7 @@ - (void)unbindWithParams:(CHIPBindingClusterUnbindParams *)params completionHand new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2603,11 +2158,7 @@ - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPBindingAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = Binding::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -2618,40 +2169,30 @@ new CHIPBindingAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Binding::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Binding::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = Binding::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -2666,51 +2207,36 @@ @implementation CHIPBooleanState - (void)readAttributeStateValueWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPBooleanAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = BooleanState::Attributes::StateValue::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = BooleanState::Attributes::StateValue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeStateValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeStateValue(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeStateValueWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPBooleanAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPBooleanAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeStateValue(success); + using TypeInfo = BooleanState::Attributes::StateValue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPBooleanStateAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = BooleanState::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -2721,40 +2247,30 @@ new CHIPBooleanStateAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = BooleanState::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = BooleanState::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = BooleanState::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -2779,7 +2295,7 @@ - (void)disableActionWithParams:(CHIPBridgedActionsClusterDisableActionParams *) new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2803,7 +2319,7 @@ - (void)disableActionWithDurationWithParams:(CHIPBridgedActionsClusterDisableAct new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2826,7 +2342,7 @@ - (void)enableActionWithParams:(CHIPBridgedActionsClusterEnableActionParams *)pa new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2850,7 +2366,7 @@ - (void)enableActionWithDurationWithParams:(CHIPBridgedActionsClusterEnableActio new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2873,7 +2389,7 @@ - (void)instantActionWithParams:(CHIPBridgedActionsClusterInstantActionParams *) new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2897,7 +2413,7 @@ - (void)instantActionWithTransitionWithParams:(CHIPBridgedActionsClusterInstantA new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2920,7 +2436,7 @@ - (void)pauseActionWithParams:(CHIPBridgedActionsClusterPauseActionParams *)para new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2944,7 +2460,7 @@ - (void)pauseActionWithDurationWithParams:(CHIPBridgedActionsClusterPauseActionW new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2967,7 +2483,7 @@ - (void)resumeActionWithParams:(CHIPBridgedActionsClusterResumeActionParams *)pa new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2990,7 +2506,7 @@ - (void)startActionWithParams:(CHIPBridgedActionsClusterStartActionParams *)para new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3014,7 +2530,7 @@ - (void)startActionWithDurationWithParams:(CHIPBridgedActionsClusterStartActionW new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3037,7 +2553,7 @@ - (void)stopActionWithParams:(CHIPBridgedActionsClusterStopActionParams *)params new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3051,11 +2567,7 @@ - (void)readAttributeActionListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPBridgedActionsActionListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = BridgedActions::Attributes::ActionList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -3063,15 +2575,29 @@ new CHIPBridgedActionsActionListListAttributeCallbackBridge( }); } +- (void)subscribeAttributeActionListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + new CHIPBridgedActionsActionListListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = BridgedActions::Attributes::ActionList::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPBridgedActionsActionListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); +} + - (void)readAttributeEndpointListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPBridgedActionsEndpointListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = BridgedActions::Attributes::EndpointList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -3079,53 +2605,57 @@ new CHIPBridgedActionsEndpointListListAttributeCallbackBridge( }); } -- (void)readAttributeSetupUrlWithCompletionHandler:(void (^)( - NSString * _Nullable value, NSError * _Nullable error))completionHandler +- (void)subscribeAttributeEndpointListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, + new CHIPBridgedActionsEndpointListListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = BridgedActions::Attributes::SetupUrl::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = BridgedActions::Attributes::EndpointList::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPBridgedActionsEndpointListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); } -- (void)subscribeAttributeSetupUrlWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)readAttributeSetupUrlWithCompletionHandler:(void (^)( + NSString * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeSetupUrl(success, failure, minInterval, maxInterval); + new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = BridgedActions::Attributes::SetupUrl::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)reportAttributeSetupUrlWithResponseHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))responseHandler +- (void)subscribeAttributeSetupUrlWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPCharStringAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeSetupUrl(success); + using TypeInfo = BridgedActions::Attributes::SetupUrl::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPBridgedActionsAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = BridgedActions::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -3136,40 +2666,30 @@ new CHIPBridgedActionsAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = BridgedActions::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = BridgedActions::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = BridgedActions::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -3185,11 +2705,7 @@ - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPBridgedDeviceBasicAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = BridgedDeviceBasic::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -3200,40 +2716,30 @@ new CHIPBridgedDeviceBasicAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = BridgedDeviceBasic::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = BridgedDeviceBasic::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); - }, - true); + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = BridgedDeviceBasic::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); } @end @@ -3260,7 +2766,7 @@ - (void)colorLoopSetWithParams:(CHIPColorControlClusterColorLoopSetParams *)para new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3282,7 +2788,7 @@ - (void)enhancedMoveHueWithParams:(CHIPColorControlClusterEnhancedMoveHueParams new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3305,7 +2811,7 @@ - (void)enhancedMoveToHueWithParams:(CHIPColorControlClusterEnhancedMoveToHuePar new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3328,7 +2834,7 @@ - (void)enhancedMoveToHueAndSaturationWithParams:(CHIPColorControlClusterEnhance new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3351,7 +2857,7 @@ - (void)enhancedStepHueWithParams:(CHIPColorControlClusterEnhancedStepHueParams new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3372,7 +2878,7 @@ - (void)moveColorWithParams:(CHIPColorControlClusterMoveColorParams *)params com new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3396,7 +2902,7 @@ - (void)moveColorTemperatureWithParams:(CHIPColorControlClusterMoveColorTemperat new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3417,7 +2923,7 @@ - (void)moveHueWithParams:(CHIPColorControlClusterMoveHueParams *)params complet new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3439,7 +2945,7 @@ - (void)moveSaturationWithParams:(CHIPColorControlClusterMoveSaturationParams *) new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3462,7 +2968,7 @@ - (void)moveToColorWithParams:(CHIPColorControlClusterMoveToColorParams *)params new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3484,7 +2990,7 @@ - (void)moveToColorTemperatureWithParams:(CHIPColorControlClusterMoveToColorTemp new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3506,7 +3012,7 @@ - (void)moveToHueWithParams:(CHIPColorControlClusterMoveToHueParams *)params com new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3529,7 +3035,7 @@ - (void)moveToHueAndSaturationWithParams:(CHIPColorControlClusterMoveToHueAndSat new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3551,7 +3057,7 @@ - (void)moveToSaturationWithParams:(CHIPColorControlClusterMoveToSaturationParam new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3573,7 +3079,7 @@ - (void)stepColorWithParams:(CHIPColorControlClusterStepColorParams *)params com new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3598,7 +3104,7 @@ - (void)stepColorTemperatureWithParams:(CHIPColorControlClusterStepColorTemperat new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3620,7 +3126,7 @@ - (void)stepHueWithParams:(CHIPColorControlClusterStepHueParams *)params complet new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3643,7 +3149,7 @@ - (void)stepSaturationWithParams:(CHIPColorControlClusterStepSaturationParams *) new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3663,7 +3169,7 @@ - (void)stopMoveStepWithParams:(CHIPColorControlClusterStopMoveStepParams *)para new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3676,372 +3182,276 @@ new CHIPCommandSuccessCallbackBridge( - (void)readAttributeCurrentHueWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::CurrentHue::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::CurrentHue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeCurrentHueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCurrentHue(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeCurrentHueWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCurrentHue(success); + using TypeInfo = ColorControl::Attributes::CurrentHue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeCurrentSaturationWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::CurrentSaturation::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::CurrentSaturation::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeCurrentSaturationWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCurrentSaturation(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeCurrentSaturationWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCurrentSaturation(success); + using TypeInfo = ColorControl::Attributes::CurrentSaturation::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeRemainingTimeWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::RemainingTime::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::RemainingTime::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeRemainingTimeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeRemainingTime(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeRemainingTimeWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeRemainingTime(success); + using TypeInfo = ColorControl::Attributes::RemainingTime::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeCurrentXWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::CurrentX::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::CurrentX::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeCurrentXWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCurrentX(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeCurrentXWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCurrentX(success); + using TypeInfo = ColorControl::Attributes::CurrentX::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeCurrentYWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::CurrentY::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::CurrentY::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeCurrentYWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCurrentY(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeCurrentYWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCurrentY(success); + using TypeInfo = ColorControl::Attributes::CurrentY::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeDriftCompensationWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::DriftCompensation::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::DriftCompensation::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeDriftCompensationWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeDriftCompensation(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeDriftCompensationWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeDriftCompensation(success); + using TypeInfo = ColorControl::Attributes::DriftCompensation::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeCompensationTextWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::CompensationText::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::CompensationText::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeCompensationTextWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCompensationText(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeCompensationTextWithResponseHandler:(void (^)(NSString * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPCharStringAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCompensationText(success); + using TypeInfo = ColorControl::Attributes::CompensationText::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeColorTemperatureWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::ColorTemperature::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::ColorTemperature::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeColorTemperatureWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeColorTemperature(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeColorTemperatureWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeColorTemperature(success); + using TypeInfo = ColorControl::Attributes::ColorTemperature::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeColorModeWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::ColorMode::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::ColorMode::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeColorModeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeColorMode(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeColorModeWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeColorMode(success); + using TypeInfo = ColorControl::Attributes::ColorMode::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeColorControlOptionsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::ColorControlOptions::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::ColorControlOptions::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeColorControlOptionsWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4057,777 +3467,578 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeColorControlOptionsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeColorControlOptions(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeColorControlOptionsWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeColorControlOptions(success); + using TypeInfo = ColorControl::Attributes::ColorControlOptions::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNumberOfPrimariesWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::NumberOfPrimaries::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::NumberOfPrimaries::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeNumberOfPrimariesWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNumberOfPrimaries(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNumberOfPrimariesWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNumberOfPrimaries(success); + using TypeInfo = ColorControl::Attributes::NumberOfPrimaries::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributePrimary1XWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::Primary1X::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::Primary1X::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributePrimary1XWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePrimary1X(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributePrimary1XWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePrimary1X(success); + using TypeInfo = ColorControl::Attributes::Primary1X::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributePrimary1YWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::Primary1Y::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::Primary1Y::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributePrimary1YWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePrimary1Y(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributePrimary1YWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePrimary1Y(success); + using TypeInfo = ColorControl::Attributes::Primary1Y::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributePrimary1IntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::Primary1Intensity::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributePrimary1IntensityWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = ColorControl::Attributes::Primary1Intensity::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); } -- (void)subscribeAttributePrimary1IntensityWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)readAttributePrimary2XWithCompletionHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePrimary1Intensity(success, failure, minInterval, maxInterval); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::Primary2X::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)reportAttributePrimary1IntensityWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler -{ - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePrimary1Intensity(success); - }, - true); -} - -- (void)readAttributePrimary2XWithCompletionHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))completionHandler +- (void)subscribeAttributePrimary2XWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = ColorControl::Attributes::Primary2X::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); -} - -- (void)subscribeAttributePrimary2XWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePrimary2X(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributePrimary2XWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePrimary2X(success); - }, - true); + subscriptionEstablishedHandler); } - (void)readAttributePrimary2YWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::Primary2Y::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::Primary2Y::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributePrimary2YWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePrimary2Y(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributePrimary2YWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePrimary2Y(success); + using TypeInfo = ColorControl::Attributes::Primary2Y::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributePrimary2IntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::Primary2Intensity::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::Primary2Intensity::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributePrimary2IntensityWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePrimary2Intensity(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributePrimary2IntensityWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePrimary2Intensity(success); + using TypeInfo = ColorControl::Attributes::Primary2Intensity::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributePrimary3XWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::Primary3X::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::Primary3X::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributePrimary3XWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePrimary3X(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributePrimary3XWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePrimary3X(success); + using TypeInfo = ColorControl::Attributes::Primary3X::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributePrimary3YWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::Primary3Y::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::Primary3Y::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributePrimary3YWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePrimary3Y(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributePrimary3YWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePrimary3Y(success); + using TypeInfo = ColorControl::Attributes::Primary3Y::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributePrimary3IntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::Primary3Intensity::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::Primary3Intensity::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributePrimary3IntensityWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePrimary3Intensity(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributePrimary3IntensityWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePrimary3Intensity(success); + using TypeInfo = ColorControl::Attributes::Primary3Intensity::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributePrimary4XWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::Primary4X::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::Primary4X::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributePrimary4XWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePrimary4X(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributePrimary4XWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePrimary4X(success); + using TypeInfo = ColorControl::Attributes::Primary4X::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributePrimary4YWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::Primary4Y::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::Primary4Y::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributePrimary4YWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePrimary4Y(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributePrimary4YWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePrimary4Y(success); + using TypeInfo = ColorControl::Attributes::Primary4Y::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributePrimary4IntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::Primary4Intensity::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::Primary4Intensity::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributePrimary4IntensityWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePrimary4Intensity(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributePrimary4IntensityWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePrimary4Intensity(success); + using TypeInfo = ColorControl::Attributes::Primary4Intensity::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributePrimary5XWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::Primary5X::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::Primary5X::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributePrimary5XWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePrimary5X(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributePrimary5XWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePrimary5X(success); + using TypeInfo = ColorControl::Attributes::Primary5X::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributePrimary5YWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::Primary5Y::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::Primary5Y::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributePrimary5YWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePrimary5Y(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributePrimary5YWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePrimary5Y(success); + using TypeInfo = ColorControl::Attributes::Primary5Y::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributePrimary5IntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::Primary5Intensity::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributePrimary5IntensityWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = ColorControl::Attributes::Primary5Intensity::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); } -- (void)subscribeAttributePrimary5IntensityWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)readAttributePrimary6XWithCompletionHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePrimary5Intensity(success, failure, minInterval, maxInterval); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::Primary6X::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)reportAttributePrimary5IntensityWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler +- (void)subscribeAttributePrimary6XWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePrimary5Intensity(success); + using TypeInfo = ColorControl::Attributes::Primary6X::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } -- (void)readAttributePrimary6XWithCompletionHandler:(void (^)( +- (void)readAttributePrimary6YWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::Primary6Y::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributePrimary6YWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::Primary6X::TypeInfo; + using TypeInfo = ColorControl::Attributes::Primary6Y::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); } -- (void)subscribeAttributePrimary6XWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)readAttributePrimary6IntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePrimary6X(success, failure, minInterval, maxInterval); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::Primary6Intensity::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)reportAttributePrimary6XWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +- (void)subscribeAttributePrimary6IntensityWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePrimary6X(success); + using TypeInfo = ColorControl::Attributes::Primary6Intensity::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); -} - -- (void)readAttributePrimary6YWithCompletionHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))completionHandler -{ - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::Primary6Y::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); -} - -- (void)subscribeAttributePrimary6YWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePrimary6Y(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributePrimary6YWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePrimary6Y(success); - }, - true); -} - -- (void)readAttributePrimary6IntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))completionHandler -{ - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::Primary6Intensity::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); -} - -- (void)subscribeAttributePrimary6IntensityWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePrimary6Intensity(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributePrimary6IntensityWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler -{ - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePrimary6Intensity(success); - }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeWhitePointXWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::WhitePointX::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::WhitePointX::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeWhitePointXWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4843,48 +4054,37 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeWhitePointXWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeWhitePointX(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeWhitePointXWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeWhitePointX(success); + using TypeInfo = ColorControl::Attributes::WhitePointX::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeWhitePointYWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::WhitePointY::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::WhitePointY::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeWhitePointYWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4900,48 +4100,37 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeWhitePointYWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeWhitePointY(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeWhitePointYWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeWhitePointY(success); + using TypeInfo = ColorControl::Attributes::WhitePointY::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeColorPointRXWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::ColorPointRX::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::ColorPointRX::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeColorPointRXWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4957,48 +4146,37 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeColorPointRXWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeColorPointRX(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeColorPointRXWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeColorPointRX(success); + using TypeInfo = ColorControl::Attributes::ColorPointRX::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeColorPointRYWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::ColorPointRY::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::ColorPointRY::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeColorPointRYWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5014,48 +4192,37 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeColorPointRYWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeColorPointRY(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeColorPointRYWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeColorPointRY(success); + using TypeInfo = ColorControl::Attributes::ColorPointRY::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeColorPointRIntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::ColorPointRIntensity::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::ColorPointRIntensity::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeColorPointRIntensityWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5071,48 +4238,39 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeColorPointRIntensityWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeColorPointRIntensity(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeColorPointRIntensityWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeColorPointRIntensity(success); + using TypeInfo = ColorControl::Attributes::ColorPointRIntensity::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeColorPointGXWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::ColorPointGX::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::ColorPointGX::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeColorPointGXWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5128,48 +4286,37 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeColorPointGXWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeColorPointGX(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeColorPointGXWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeColorPointGX(success); + using TypeInfo = ColorControl::Attributes::ColorPointGX::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeColorPointGYWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::ColorPointGY::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::ColorPointGY::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeColorPointGYWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5185,48 +4332,37 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeColorPointGYWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeColorPointGY(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeColorPointGYWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeColorPointGY(success); + using TypeInfo = ColorControl::Attributes::ColorPointGY::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeColorPointGIntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::ColorPointGIntensity::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::ColorPointGIntensity::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeColorPointGIntensityWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5242,48 +4378,39 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeColorPointGIntensityWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeColorPointGIntensity(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeColorPointGIntensityWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeColorPointGIntensity(success); + using TypeInfo = ColorControl::Attributes::ColorPointGIntensity::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeColorPointBXWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::ColorPointBX::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::ColorPointBX::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeColorPointBXWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5299,48 +4426,37 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeColorPointBXWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeColorPointBX(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeColorPointBXWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeColorPointBX(success); + using TypeInfo = ColorControl::Attributes::ColorPointBX::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeColorPointBYWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::ColorPointBY::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::ColorPointBY::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeColorPointBYWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5356,48 +4472,37 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeColorPointBYWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeColorPointBY(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeColorPointBYWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeColorPointBY(success); + using TypeInfo = ColorControl::Attributes::ColorPointBY::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeColorPointBIntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::ColorPointBIntensity::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::ColorPointBIntensity::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeColorPointBIntensityWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5413,470 +4518,356 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeColorPointBIntensityWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeColorPointBIntensity(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeColorPointBIntensityWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeColorPointBIntensity(success); + using TypeInfo = ColorControl::Attributes::ColorPointBIntensity::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeEnhancedCurrentHueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::EnhancedCurrentHue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributeEnhancedCurrentHueWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = ColorControl::Attributes::EnhancedCurrentHue::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); -} - -- (void)subscribeAttributeEnhancedCurrentHueWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeEnhancedCurrentHue(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeEnhancedCurrentHueWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler -{ - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeEnhancedCurrentHue(success); - }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeEnhancedColorModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::EnhancedColorMode::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::EnhancedColorMode::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeEnhancedColorModeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeEnhancedColorMode(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeEnhancedColorModeWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeEnhancedColorMode(success); + using TypeInfo = ColorControl::Attributes::EnhancedColorMode::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeColorLoopActiveWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::ColorLoopActive::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::ColorLoopActive::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeColorLoopActiveWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeColorLoopActive(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeColorLoopActiveWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeColorLoopActive(success); + using TypeInfo = ColorControl::Attributes::ColorLoopActive::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeColorLoopDirectionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::ColorLoopDirection::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::ColorLoopDirection::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeColorLoopDirectionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeColorLoopDirection(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeColorLoopDirectionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeColorLoopDirection(success); + using TypeInfo = ColorControl::Attributes::ColorLoopDirection::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeColorLoopTimeWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::ColorLoopTime::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::ColorLoopTime::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeColorLoopTimeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeColorLoopTime(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeColorLoopTimeWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeColorLoopTime(success); + using TypeInfo = ColorControl::Attributes::ColorLoopTime::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeColorLoopStartEnhancedHueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::ColorLoopStartEnhancedHue::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::ColorLoopStartEnhancedHue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeColorLoopStartEnhancedHueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeColorLoopStartEnhancedHue(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeColorLoopStartEnhancedHueWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeColorLoopStartEnhancedHue(success); + using TypeInfo = ColorControl::Attributes::ColorLoopStartEnhancedHue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeColorLoopStoredEnhancedHueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::ColorLoopStoredEnhancedHue::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::ColorLoopStoredEnhancedHue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeColorLoopStoredEnhancedHueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeColorLoopStoredEnhancedHue(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeColorLoopStoredEnhancedHueWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeColorLoopStoredEnhancedHue(success); + using TypeInfo = ColorControl::Attributes::ColorLoopStoredEnhancedHue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeColorCapabilitiesWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::ColorCapabilities::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::ColorCapabilities::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeColorCapabilitiesWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeColorCapabilities(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeColorCapabilitiesWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeColorCapabilities(success); + using TypeInfo = ColorControl::Attributes::ColorCapabilities::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeColorTempPhysicalMinWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::ColorTempPhysicalMin::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::ColorTempPhysicalMin::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeColorTempPhysicalMinWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeColorTempPhysicalMin(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeColorTempPhysicalMinWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeColorTempPhysicalMin(success); + using TypeInfo = ColorControl::Attributes::ColorTempPhysicalMin::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeColorTempPhysicalMaxWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::ColorTempPhysicalMax::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::ColorTempPhysicalMax::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeColorTempPhysicalMaxWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeColorTempPhysicalMax(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeColorTempPhysicalMaxWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeColorTempPhysicalMax(success); + using TypeInfo = ColorControl::Attributes::ColorTempPhysicalMax::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeCoupleColorTempToLevelMinMiredsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::CoupleColorTempToLevelMinMireds::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::CoupleColorTempToLevelMinMireds::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeCoupleColorTempToLevelMinMiredsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCoupleColorTempToLevelMinMireds(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeCoupleColorTempToLevelMinMiredsWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCoupleColorTempToLevelMinMireds(success); + using TypeInfo = ColorControl::Attributes::CoupleColorTempToLevelMinMireds::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeStartUpColorTemperatureMiredsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::StartUpColorTemperatureMireds::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::StartUpColorTemperatureMireds::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeStartUpColorTemperatureMiredsWithValue:(NSNumber * _Nonnull)value @@ -5884,7 +4875,7 @@ - (void)writeAttributeStartUpColorTemperatureMiredsWithValue:(NSNumber * _Nonnul { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5900,36 +4891,28 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeStartUpColorTemperatureMiredsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeStartUpColorTemperatureMireds(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeStartUpColorTemperatureMiredsWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeStartUpColorTemperatureMireds(success); + using TypeInfo = ColorControl::Attributes::StartUpColorTemperatureMireds::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPColorControlAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = ColorControl::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -5940,40 +4923,30 @@ new CHIPColorControlAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ColorControl::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ColorControl::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = ColorControl::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -5995,11 +4968,7 @@ - (void)launchContentWithParams:(CHIPContentLauncherClusterLaunchContentParams * request.data = [self asCharSpan:params.data]; new CHIPContentLauncherClusterLaunchContentResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -6016,11 +4985,7 @@ - (void)launchURLWithParams:(CHIPContentLauncherClusterLaunchURLParams *)params request.displayString = [self asCharSpan:params.displayString]; new CHIPContentLauncherClusterLaunchURLResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -6031,11 +4996,7 @@ - (void)readAttributeAcceptsHeaderListWithCompletionHandler:(void (^)(NSArray * NSError * _Nullable error))completionHandler { new CHIPContentLauncherAcceptsHeaderListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = ContentLauncher::Attributes::AcceptsHeaderList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -6043,15 +5004,30 @@ new CHIPContentLauncherAcceptsHeaderListListAttributeCallbackBridge( }); } +- (void)subscribeAttributeAcceptsHeaderListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + new CHIPContentLauncherAcceptsHeaderListListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ContentLauncher::Attributes::AcceptsHeaderList::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPContentLauncherAcceptsHeaderListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); +} + - (void)readAttributeSupportedStreamingTypesWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPContentLauncherSupportedStreamingTypesListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = ContentLauncher::Attributes::SupportedStreamingTypes::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -6059,15 +5035,31 @@ new CHIPContentLauncherSupportedStreamingTypesListAttributeCallbackBridge( }); } -- (void)readAttributeAttributeListWithCompletionHandler:(void (^)( - NSArray * _Nullable value, NSError * _Nullable error))completionHandler +- (void)subscribeAttributeSupportedStreamingTypesWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPContentLauncherAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, + new CHIPContentLauncherSupportedStreamingTypesListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ContentLauncher::Attributes::SupportedStreamingTypes::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPContentLauncherSupportedStreamingTypesListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); +} + +- (void)readAttributeAttributeListWithCompletionHandler:(void (^)( + NSArray * _Nullable value, NSError * _Nullable error))completionHandler +{ + new CHIPContentLauncherAttributeListListAttributeCallbackBridge( + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = ContentLauncher::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -6078,40 +5070,30 @@ new CHIPContentLauncherAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ContentLauncher::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ContentLauncher::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = ContentLauncher::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -6127,11 +5109,7 @@ - (void)readAttributeDeviceListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPDescriptorDeviceListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = Descriptor::Attributes::DeviceList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -6139,15 +5117,29 @@ new CHIPDescriptorDeviceListListAttributeCallbackBridge( }); } +- (void)subscribeAttributeDeviceListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + new CHIPDescriptorDeviceListListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Descriptor::Attributes::DeviceList::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPDescriptorDeviceListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); +} + - (void)readAttributeServerListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPDescriptorServerListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = Descriptor::Attributes::ServerList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -6155,15 +5147,29 @@ new CHIPDescriptorServerListListAttributeCallbackBridge( }); } +- (void)subscribeAttributeServerListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + new CHIPDescriptorServerListListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Descriptor::Attributes::ServerList::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPDescriptorServerListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); +} + - (void)readAttributeClientListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPDescriptorClientListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = Descriptor::Attributes::ClientList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -6171,15 +5177,29 @@ new CHIPDescriptorClientListListAttributeCallbackBridge( }); } +- (void)subscribeAttributeClientListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + new CHIPDescriptorClientListListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Descriptor::Attributes::ClientList::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPDescriptorClientListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); +} + - (void)readAttributePartsListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPDescriptorPartsListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = Descriptor::Attributes::PartsList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -6187,15 +5207,29 @@ new CHIPDescriptorPartsListListAttributeCallbackBridge( }); } +- (void)subscribeAttributePartsListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + new CHIPDescriptorPartsListListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Descriptor::Attributes::PartsList::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPDescriptorPartsListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); +} + - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPDescriptorAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = Descriptor::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -6206,40 +5240,30 @@ new CHIPDescriptorAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Descriptor::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Descriptor::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = Descriptor::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -6263,11 +5287,7 @@ - (void)retrieveLogsRequestWithParams:(CHIPDiagnosticLogsClusterRetrieveLogsRequ request.transferFileDesignator = [self asByteSpan:params.transferFileDesignator]; new CHIPDiagnosticLogsClusterRetrieveLogsResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -6278,11 +5298,7 @@ - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPDiagnosticLogsAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = DiagnosticLogs::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -6306,7 +5322,7 @@ - (void)clearAllPINCodesWithCompletionHandler:(StatusCompletion)completionHandle new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6323,7 +5339,7 @@ - (void)clearAllRFIDCodesWithCompletionHandler:(StatusCompletion)completionHandl new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6342,7 +5358,7 @@ - (void)clearHolidayScheduleWithParams:(CHIPDoorLockClusterClearHolidayScheduleP new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6360,7 +5376,7 @@ - (void)clearPINCodeWithParams:(CHIPDoorLockClusterClearPINCodeParams *)params c new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6379,7 +5395,7 @@ - (void)clearRFIDCodeWithParams:(CHIPDoorLockClusterClearRFIDCodeParams *)params new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6399,7 +5415,7 @@ - (void)clearWeekDayScheduleWithParams:(CHIPDoorLockClusterClearWeekDayScheduleP new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6419,7 +5435,7 @@ - (void)clearYearDayScheduleWithParams:(CHIPDoorLockClusterClearYearDayScheduleP new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6438,11 +5454,7 @@ - (void)getHolidayScheduleWithParams:(CHIPDoorLockClusterGetHolidayScheduleParam request.holidayIndex = params.holidayIndex.unsignedCharValue; new CHIPDoorLockClusterGetHolidayScheduleResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -6458,11 +5470,7 @@ - (void)getLogRecordWithParams:(CHIPDoorLockClusterGetLogRecordParams *)params request.logIndex = params.logIndex.unsignedShortValue; new CHIPDoorLockClusterGetLogRecordResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -6478,11 +5486,7 @@ - (void)getPINCodeWithParams:(CHIPDoorLockClusterGetPINCodeParams *)params request.userId = params.userId.unsignedShortValue; new CHIPDoorLockClusterGetPINCodeResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -6498,11 +5502,7 @@ - (void)getRFIDCodeWithParams:(CHIPDoorLockClusterGetRFIDCodeParams *)params request.userId = params.userId.unsignedShortValue; new CHIPDoorLockClusterGetRFIDCodeResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -6518,11 +5518,7 @@ - (void)getUserTypeWithParams:(CHIPDoorLockClusterGetUserTypeParams *)params request.userId = params.userId.unsignedShortValue; new CHIPDoorLockClusterGetUserTypeResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -6539,11 +5535,7 @@ - (void)getWeekDayScheduleWithParams:(CHIPDoorLockClusterGetWeekDayScheduleParam request.userIndex = params.userIndex.unsignedShortValue; new CHIPDoorLockClusterGetWeekDayScheduleResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -6560,11 +5552,7 @@ - (void)getYearDayScheduleWithParams:(CHIPDoorLockClusterGetYearDayScheduleParam request.userIndex = params.userIndex.unsignedShortValue; new CHIPDoorLockClusterGetYearDayScheduleResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -6585,7 +5573,7 @@ - (void)lockDoorWithParams:(CHIPDoorLockClusterLockDoorParams * _Nullable)params new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6608,7 +5596,7 @@ - (void)setHolidayScheduleWithParams:(CHIPDoorLockClusterSetHolidayScheduleParam new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6629,7 +5617,7 @@ - (void)setPINCodeWithParams:(CHIPDoorLockClusterSetPINCodeParams *)params compl new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6650,7 +5638,7 @@ - (void)setRFIDCodeWithParams:(CHIPDoorLockClusterSetRFIDCodeParams *)params com new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6669,7 +5657,7 @@ - (void)setUserTypeWithParams:(CHIPDoorLockClusterSetUserTypeParams *)params com new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6694,7 +5682,7 @@ - (void)setWeekDayScheduleWithParams:(CHIPDoorLockClusterSetWeekDayScheduleParam new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6716,7 +5704,7 @@ - (void)setYearDayScheduleWithParams:(CHIPDoorLockClusterSetYearDayScheduleParam new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6740,7 +5728,7 @@ - (void)unlockDoorWithParams:(CHIPDoorLockClusterUnlockDoorParams * _Nullable)pa new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6763,7 +5751,7 @@ - (void)unlockWithTimeoutWithParams:(CHIPDoorLockClusterUnlockWithTimeoutParams new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6777,11 +5765,7 @@ - (void)readAttributeLockStateWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableDoorLockClusterDlLockStateAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = DoorLock::Attributes::LockState::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -6791,36 +5775,27 @@ new CHIPNullableDoorLockClusterDlLockStateAttributeCallbackBridge( - (void)subscribeAttributeLockStateWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt8uAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeLockState(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeLockStateWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeLockState(success); + using TypeInfo = DoorLock::Attributes::LockState::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPNullableDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeLockTypeWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPDoorLockClusterDlLockTypeAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = DoorLock::Attributes::LockType::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -6830,74 +5805,56 @@ new CHIPDoorLockClusterDlLockTypeAttributeCallbackBridge( - (void)subscribeAttributeLockTypeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeLockType(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeLockTypeWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeLockType(success); + using TypeInfo = DoorLock::Attributes::LockType::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeActuatorEnabledWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPBooleanAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = DoorLock::Attributes::ActuatorEnabled::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = DoorLock::Attributes::ActuatorEnabled::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeActuatorEnabledWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeActuatorEnabled(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeActuatorEnabledWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPBooleanAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPBooleanAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeActuatorEnabled(success); + using TypeInfo = DoorLock::Attributes::ActuatorEnabled::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPDoorLockAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = DoorLock::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -6908,40 +5865,30 @@ new CHIPDoorLockAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = DoorLock::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = DoorLock::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = DoorLock::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -6956,441 +5903,324 @@ @implementation CHIPElectricalMeasurement - (void)readAttributeMeasurementTypeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ElectricalMeasurement::Attributes::MeasurementType::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ElectricalMeasurement::Attributes::MeasurementType::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeMeasurementTypeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMeasurementType(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMeasurementTypeWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMeasurementType(success); + using TypeInfo = ElectricalMeasurement::Attributes::MeasurementType::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeTotalActivePowerWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ElectricalMeasurement::Attributes::TotalActivePower::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ElectricalMeasurement::Attributes::TotalActivePower::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeTotalActivePowerWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeTotalActivePower(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeTotalActivePowerWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeTotalActivePower(success); + using TypeInfo = ElectricalMeasurement::Attributes::TotalActivePower::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeRmsVoltageWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltage::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltage::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeRmsVoltageWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeRmsVoltage(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeRmsVoltageWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeRmsVoltage(success); + using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltage::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeRmsVoltageMinWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMin::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMin::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeRmsVoltageMinWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeRmsVoltageMin(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeRmsVoltageMinWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeRmsVoltageMin(success); + using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMin::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeRmsVoltageMaxWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMax::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMax::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeRmsVoltageMaxWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeRmsVoltageMax(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeRmsVoltageMaxWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeRmsVoltageMax(success); + using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMax::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeRmsCurrentWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrent::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrent::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeRmsCurrentWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeRmsCurrent(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeRmsCurrentWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeRmsCurrent(success); + using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrent::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeRmsCurrentMinWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMin::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMin::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeRmsCurrentMinWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeRmsCurrentMin(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeRmsCurrentMinWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeRmsCurrentMin(success); + using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMin::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeRmsCurrentMaxWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMax::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMax::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeRmsCurrentMaxWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeRmsCurrentMax(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeRmsCurrentMaxWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeRmsCurrentMax(success); + using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMax::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeActivePowerWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ElectricalMeasurement::Attributes::ActivePower::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ElectricalMeasurement::Attributes::ActivePower::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeActivePowerWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeActivePower(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeActivePowerWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeActivePower(success); + using TypeInfo = ElectricalMeasurement::Attributes::ActivePower::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeActivePowerMinWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMin::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMin::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeActivePowerMinWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeActivePowerMin(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeActivePowerMinWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeActivePowerMin(success); + using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMin::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeActivePowerMaxWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMax::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMax::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeActivePowerMaxWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeActivePowerMax(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeActivePowerMaxWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeActivePowerMax(success); + using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMax::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPElectricalMeasurementAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = ElectricalMeasurement::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -7401,40 +6231,30 @@ new CHIPElectricalMeasurementAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ElectricalMeasurement::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ElectricalMeasurement::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = ElectricalMeasurement::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -7453,7 +6273,7 @@ - (void)resetCountsWithCompletionHandler:(StatusCompletion)completionHandler new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7465,362 +6285,265 @@ new CHIPCommandSuccessCallbackBridge( - (void)readAttributePHYRateWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = EthernetNetworkDiagnostics::Attributes::PHYRate::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = EthernetNetworkDiagnostics::Attributes::PHYRate::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributePHYRateWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePHYRate(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributePHYRateWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePHYRate(success); + using TypeInfo = EthernetNetworkDiagnostics::Attributes::PHYRate::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeFullDuplexWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPBooleanAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = EthernetNetworkDiagnostics::Attributes::FullDuplex::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = EthernetNetworkDiagnostics::Attributes::FullDuplex::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeFullDuplexWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeFullDuplex(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeFullDuplexWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPBooleanAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPBooleanAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeFullDuplex(success); + using TypeInfo = EthernetNetworkDiagnostics::Attributes::FullDuplex::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributePacketRxCountWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = EthernetNetworkDiagnostics::Attributes::PacketRxCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = EthernetNetworkDiagnostics::Attributes::PacketRxCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributePacketRxCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePacketRxCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributePacketRxCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePacketRxCount(success); + using TypeInfo = EthernetNetworkDiagnostics::Attributes::PacketRxCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributePacketTxCountWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = EthernetNetworkDiagnostics::Attributes::PacketTxCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = EthernetNetworkDiagnostics::Attributes::PacketTxCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributePacketTxCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePacketTxCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributePacketTxCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePacketTxCount(success); + using TypeInfo = EthernetNetworkDiagnostics::Attributes::PacketTxCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeTxErrCountWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = EthernetNetworkDiagnostics::Attributes::TxErrCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = EthernetNetworkDiagnostics::Attributes::TxErrCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeTxErrCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeTxErrCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeTxErrCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeTxErrCount(success); + using TypeInfo = EthernetNetworkDiagnostics::Attributes::TxErrCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeCollisionCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = EthernetNetworkDiagnostics::Attributes::CollisionCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = EthernetNetworkDiagnostics::Attributes::CollisionCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeCollisionCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCollisionCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeCollisionCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCollisionCount(success); + using TypeInfo = EthernetNetworkDiagnostics::Attributes::CollisionCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeOverrunCountWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = EthernetNetworkDiagnostics::Attributes::OverrunCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = EthernetNetworkDiagnostics::Attributes::OverrunCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeOverrunCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeOverrunCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeOverrunCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeOverrunCount(success); + using TypeInfo = EthernetNetworkDiagnostics::Attributes::OverrunCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeCarrierDetectWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPBooleanAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = EthernetNetworkDiagnostics::Attributes::CarrierDetect::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = EthernetNetworkDiagnostics::Attributes::CarrierDetect::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeCarrierDetectWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCarrierDetect(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeCarrierDetectWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPBooleanAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPBooleanAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCarrierDetect(success); + using TypeInfo = EthernetNetworkDiagnostics::Attributes::CarrierDetect::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeTimeSinceResetWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = EthernetNetworkDiagnostics::Attributes::TimeSinceReset::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = EthernetNetworkDiagnostics::Attributes::TimeSinceReset::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeTimeSinceResetWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeTimeSinceReset(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeTimeSinceResetWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeTimeSinceReset(success); + using TypeInfo = EthernetNetworkDiagnostics::Attributes::TimeSinceReset::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPEthernetNetworkDiagnosticsAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = EthernetNetworkDiagnostics::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -7831,56 +6554,41 @@ new CHIPEthernetNetworkDiagnosticsAttributeListListAttributeCallbackBridge( - (void)readAttributeFeatureMapWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = EthernetNetworkDiagnostics::Attributes::FeatureMap::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = EthernetNetworkDiagnostics::Attributes::FeatureMap::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = EthernetNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = EthernetNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = EthernetNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -7896,11 +6604,7 @@ - (void)readAttributeLabelListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPFixedLabelLabelListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = FixedLabel::Attributes::LabelList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -7908,15 +6612,29 @@ new CHIPFixedLabelLabelListListAttributeCallbackBridge( }); } +- (void)subscribeAttributeLabelListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + new CHIPFixedLabelLabelListListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = FixedLabel::Attributes::LabelList::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPFixedLabelLabelListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); +} + - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPFixedLabelAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = FixedLabel::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -7927,40 +6645,30 @@ new CHIPFixedLabelAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = FixedLabel::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = FixedLabel::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = FixedLabel::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -7975,167 +6683,123 @@ @implementation CHIPFlowMeasurement - (void)readAttributeMeasuredValueWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = FlowMeasurement::Attributes::MeasuredValue::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = FlowMeasurement::Attributes::MeasuredValue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMeasuredValue(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMeasuredValueWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMeasuredValue(success); + using TypeInfo = FlowMeasurement::Attributes::MeasuredValue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeMinMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = FlowMeasurement::Attributes::MinMeasuredValue::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = FlowMeasurement::Attributes::MinMeasuredValue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeMinMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMinMeasuredValue(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMinMeasuredValueWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMinMeasuredValue(success); + using TypeInfo = FlowMeasurement::Attributes::MinMeasuredValue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeMaxMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = FlowMeasurement::Attributes::MaxMeasuredValue::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = FlowMeasurement::Attributes::MaxMeasuredValue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeMaxMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMaxMeasuredValue(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMaxMeasuredValueWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMaxMeasuredValue(success); + using TypeInfo = FlowMeasurement::Attributes::MaxMeasuredValue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeToleranceWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = FlowMeasurement::Attributes::Tolerance::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = FlowMeasurement::Attributes::Tolerance::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeToleranceWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeTolerance(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeToleranceWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeTolerance(success); + using TypeInfo = FlowMeasurement::Attributes::Tolerance::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPFlowMeasurementAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = FlowMeasurement::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -8146,40 +6810,30 @@ new CHIPFlowMeasurementAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = FlowMeasurement::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = FlowMeasurement::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = FlowMeasurement::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -8202,11 +6856,7 @@ - (void)armFailSafeWithParams:(CHIPGeneralCommissioningClusterArmFailSafeParams request.timeoutMs = params.timeoutMs.unsignedIntValue; new CHIPGeneralCommissioningClusterArmFailSafeResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -8221,11 +6871,7 @@ - (void)commissioningCompleteWithCompletionHandler: GeneralCommissioning::Commands::CommissioningComplete::Type request; new CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -8245,11 +6891,7 @@ - (void)setRegulatoryConfigWithParams:(CHIPGeneralCommissioningClusterSetRegulat request.timeoutMs = params.timeoutMs.unsignedIntValue; new CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -8260,24 +6902,19 @@ new CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallbackBridge( - (void)readAttributeBreadcrumbWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = GeneralCommissioning::Attributes::Breadcrumb::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = GeneralCommissioning::Attributes::Breadcrumb::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeBreadcrumbWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -8293,36 +6930,26 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeBreadcrumbWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeBreadcrumb(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeBreadcrumbWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeBreadcrumb(success); + using TypeInfo = GeneralCommissioning::Attributes::Breadcrumb::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeBasicCommissioningInfoListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPGeneralCommissioningBasicCommissioningInfoListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = GeneralCommissioning::Attributes::BasicCommissioningInfoList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -8330,47 +6957,54 @@ new CHIPGeneralCommissioningBasicCommissioningInfoListListAttributeCallbackBridg }); } -- (void)readAttributeRegulatoryConfigWithCompletionHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))completionHandler +- (void)subscribeAttributeBasicCommissioningInfoListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, + new CHIPGeneralCommissioningBasicCommissioningInfoListListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = GeneralCommissioning::Attributes::RegulatoryConfig::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = GeneralCommissioning::Attributes::BasicCommissioningInfoList::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPGeneralCommissioningBasicCommissioningInfoListListAttributeCallbackSubscriptionBridge:: + OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); +} + +- (void)readAttributeRegulatoryConfigWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler +{ + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = GeneralCommissioning::Attributes::RegulatoryConfig::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)readAttributeLocationCapabilityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = GeneralCommissioning::Attributes::LocationCapability::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = GeneralCommissioning::Attributes::LocationCapability::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPGeneralCommissioningAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = GeneralCommissioning::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -8381,40 +7015,30 @@ new CHIPGeneralCommissioningAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = GeneralCommissioning::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = GeneralCommissioning::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = GeneralCommissioning::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -8430,11 +7054,7 @@ - (void)readAttributeNetworkInterfacesWithCompletionHandler:(void (^)(NSArray * NSError * _Nullable error))completionHandler { new CHIPGeneralDiagnosticsNetworkInterfacesListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = GeneralDiagnostics::Attributes::NetworkInterfaces::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -8442,169 +7062,143 @@ new CHIPGeneralDiagnosticsNetworkInterfacesListAttributeCallbackBridge( }); } -- (void)readAttributeRebootCountWithCompletionHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))completionHandler +- (void)subscribeAttributeNetworkInterfacesWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, + new CHIPGeneralDiagnosticsNetworkInterfacesListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = GeneralDiagnostics::Attributes::RebootCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = GeneralDiagnostics::Attributes::NetworkInterfaces::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPGeneralDiagnosticsNetworkInterfacesListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); } -- (void)subscribeAttributeRebootCountWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)readAttributeRebootCountWithCompletionHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeRebootCount(success, failure, minInterval, maxInterval); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = GeneralDiagnostics::Attributes::RebootCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)reportAttributeRebootCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +- (void)subscribeAttributeRebootCountWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeRebootCount(success); + using TypeInfo = GeneralDiagnostics::Attributes::RebootCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeUpTimeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = GeneralDiagnostics::Attributes::UpTime::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = GeneralDiagnostics::Attributes::UpTime::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeUpTimeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeUpTime(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeUpTimeWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeUpTime(success); + using TypeInfo = GeneralDiagnostics::Attributes::UpTime::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeTotalOperationalHoursWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = GeneralDiagnostics::Attributes::TotalOperationalHours::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = GeneralDiagnostics::Attributes::TotalOperationalHours::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeTotalOperationalHoursWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeTotalOperationalHours(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeTotalOperationalHoursWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeTotalOperationalHours(success); + using TypeInfo = GeneralDiagnostics::Attributes::TotalOperationalHours::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeBootReasonsWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = GeneralDiagnostics::Attributes::BootReasons::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = GeneralDiagnostics::Attributes::BootReasons::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeBootReasonsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeBootReasons(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeBootReasonsWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeBootReasons(success); + using TypeInfo = GeneralDiagnostics::Attributes::BootReasons::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeActiveHardwareFaultsWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = GeneralDiagnostics::Attributes::ActiveHardwareFaults::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -8612,15 +7206,31 @@ new CHIPGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackBridge( }); } +- (void)subscribeAttributeActiveHardwareFaultsWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + new CHIPGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = GeneralDiagnostics::Attributes::ActiveHardwareFaults::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); +} + - (void)readAttributeActiveRadioFaultsWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = GeneralDiagnostics::Attributes::ActiveRadioFaults::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -8628,15 +7238,30 @@ new CHIPGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackBridge( }); } +- (void)subscribeAttributeActiveRadioFaultsWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + new CHIPGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = GeneralDiagnostics::Attributes::ActiveRadioFaults::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); +} + - (void)readAttributeActiveNetworkFaultsWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = GeneralDiagnostics::Attributes::ActiveNetworkFaults::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -8644,15 +7269,31 @@ new CHIPGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackBridge( }); } +- (void)subscribeAttributeActiveNetworkFaultsWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + new CHIPGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = GeneralDiagnostics::Attributes::ActiveNetworkFaults::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); +} + - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPGeneralDiagnosticsAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = GeneralDiagnostics::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -8663,40 +7304,30 @@ new CHIPGeneralDiagnosticsAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = GeneralDiagnostics::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = GeneralDiagnostics::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = GeneralDiagnostics::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -8711,11 +7342,7 @@ @implementation CHIPGroupKeyManagement - (void)readAttributeGroupsWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPGroupKeyManagementGroupsListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = GroupKeyManagement::Attributes::Groups::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -8723,15 +7350,29 @@ new CHIPGroupKeyManagementGroupsListAttributeCallbackBridge( }); } +- (void)subscribeAttributeGroupsWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + new CHIPGroupKeyManagementGroupsListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = GroupKeyManagement::Attributes::Groups::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPGroupKeyManagementGroupsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); +} + - (void)readAttributeGroupKeysWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPGroupKeyManagementGroupKeysListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = GroupKeyManagement::Attributes::GroupKeys::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -8739,15 +7380,29 @@ new CHIPGroupKeyManagementGroupKeysListAttributeCallbackBridge( }); } +- (void)subscribeAttributeGroupKeysWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + new CHIPGroupKeyManagementGroupKeysListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = GroupKeyManagement::Attributes::GroupKeys::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPGroupKeyManagementGroupKeysListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); +} + - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPGroupKeyManagementAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = GroupKeyManagement::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -8758,40 +7413,30 @@ new CHIPGroupKeyManagementAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = GroupKeyManagement::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = GroupKeyManagement::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = GroupKeyManagement::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -8813,11 +7458,7 @@ - (void)addGroupWithParams:(CHIPGroupsClusterAddGroupParams *)params request.groupName = [self asCharSpan:params.groupName]; new CHIPGroupsClusterAddGroupResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -8834,7 +7475,7 @@ - (void)addGroupIfIdentifyingWithParams:(CHIPGroupsClusterAddGroupIfIdentifyingP new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -8874,11 +7515,7 @@ - (void)getGroupMembershipWithParams:(CHIPGroupsClusterGetGroupMembershipParams } new CHIPGroupsClusterGetGroupMembershipResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -8892,7 +7529,7 @@ - (void)removeAllGroupsWithCompletionHandler:(StatusCompletion)completionHandler new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -8911,11 +7548,7 @@ - (void)removeGroupWithParams:(CHIPGroupsClusterRemoveGroupParams *)params request.groupId = params.groupId.unsignedShortValue; new CHIPGroupsClusterRemoveGroupResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -8931,11 +7564,7 @@ - (void)viewGroupWithParams:(CHIPGroupsClusterViewGroupParams *)params request.groupId = params.groupId.unsignedShortValue; new CHIPGroupsClusterViewGroupResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -8945,51 +7574,36 @@ new CHIPGroupsClusterViewGroupResponseCallbackBridge( - (void)readAttributeNameSupportWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Groups::Attributes::NameSupport::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Groups::Attributes::NameSupport::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeNameSupportWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNameSupport(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNameSupportWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNameSupport(success); + using TypeInfo = Groups::Attributes::NameSupport::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPGroupsAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = Groups::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -9000,40 +7614,30 @@ new CHIPGroupsAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Groups::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Groups::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = Groups::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -9053,7 +7657,7 @@ - (void)identifyWithParams:(CHIPIdentifyClusterIdentifyParams *)params completio new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9070,11 +7674,7 @@ - (void)identifyQueryWithCompletionHandler:(void (^)(CHIPIdentifyClusterIdentify Identify::Commands::IdentifyQuery::Type request; new CHIPIdentifyClusterIdentifyQueryResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -9093,7 +7693,7 @@ - (void)triggerEffectWithParams:(CHIPIdentifyClusterTriggerEffectParams *)params new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9106,24 +7706,19 @@ new CHIPCommandSuccessCallbackBridge( - (void)readAttributeIdentifyTimeWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Identify::Attributes::IdentifyTime::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Identify::Attributes::IdentifyTime::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeIdentifyTimeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9139,75 +7734,54 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeIdentifyTimeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeIdentifyTime(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeIdentifyTimeWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeIdentifyTime(success); + using TypeInfo = Identify::Attributes::IdentifyTime::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeIdentifyTypeWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Identify::Attributes::IdentifyType::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Identify::Attributes::IdentifyType::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeIdentifyTypeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeIdentifyType(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeIdentifyTypeWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeIdentifyType(success); + using TypeInfo = Identify::Attributes::IdentifyType::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPIdentifyAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = Identify::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -9218,40 +7792,30 @@ new CHIPIdentifyAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Identify::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Identify::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = Identify::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -9267,11 +7831,7 @@ - (void)readAttributeMeasuredValueWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = IlluminanceMeasurement::Attributes::MeasuredValue::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -9281,37 +7841,27 @@ new CHIPNullableInt16uAttributeCallbackBridge( - (void)subscribeAttributeMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt16uAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMeasuredValue(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMeasuredValueWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMeasuredValue(success); + using TypeInfo = IlluminanceMeasurement::Attributes::MeasuredValue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeMinMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = IlluminanceMeasurement::Attributes::MinMeasuredValue::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -9321,37 +7871,27 @@ new CHIPNullableInt16uAttributeCallbackBridge( - (void)subscribeAttributeMinMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt16uAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMinMeasuredValue(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMinMeasuredValueWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMinMeasuredValue(success); + using TypeInfo = IlluminanceMeasurement::Attributes::MinMeasuredValue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeMaxMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = IlluminanceMeasurement::Attributes::MaxMeasuredValue::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -9361,75 +7901,55 @@ new CHIPNullableInt16uAttributeCallbackBridge( - (void)subscribeAttributeMaxMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt16uAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMaxMeasuredValue(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMaxMeasuredValueWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMaxMeasuredValue(success); + using TypeInfo = IlluminanceMeasurement::Attributes::MaxMeasuredValue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeToleranceWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = IlluminanceMeasurement::Attributes::Tolerance::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = IlluminanceMeasurement::Attributes::Tolerance::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeToleranceWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeTolerance(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeToleranceWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeTolerance(success); + using TypeInfo = IlluminanceMeasurement::Attributes::Tolerance::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeLightSensorTypeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = IlluminanceMeasurement::Attributes::LightSensorType::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -9439,37 +7959,27 @@ new CHIPNullableInt8uAttributeCallbackBridge( - (void)subscribeAttributeLightSensorTypeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt8uAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeLightSensorType(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeLightSensorTypeWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeLightSensorType(success); + using TypeInfo = IlluminanceMeasurement::Attributes::LightSensorType::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPIlluminanceMeasurementAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = IlluminanceMeasurement::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -9480,40 +7990,30 @@ new CHIPIlluminanceMeasurementAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = IlluminanceMeasurement::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = IlluminanceMeasurement::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = IlluminanceMeasurement::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -9534,11 +8034,7 @@ - (void)sendKeyWithParams:(CHIPKeypadInputClusterSendKeyParams *)params request.keyCode = static_cast>(params.keyCode.unsignedCharValue); new CHIPKeypadInputClusterSendKeyResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -9549,11 +8045,7 @@ - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPKeypadInputAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = KeypadInput::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -9564,40 +8056,30 @@ new CHIPKeypadInputAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = KeypadInput::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = KeypadInput::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = KeypadInput::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -9620,7 +8102,7 @@ - (void)moveWithParams:(CHIPLevelControlClusterMoveParams *)params completionHan new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9642,7 +8124,7 @@ - (void)moveToLevelWithParams:(CHIPLevelControlClusterMoveToLevelParams *)params new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9662,7 +8144,7 @@ - (void)moveToLevelWithOnOffWithParams:(CHIPLevelControlClusterMoveToLevelWithOn new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9682,7 +8164,7 @@ - (void)moveWithOnOffWithParams:(CHIPLevelControlClusterMoveWithOnOffParams *)pa new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9704,7 +8186,7 @@ - (void)stepWithParams:(CHIPLevelControlClusterStepParams *)params completionHan new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9725,7 +8207,7 @@ - (void)stepWithOnOffWithParams:(CHIPLevelControlClusterStepWithOnOffParams *)pa new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9744,7 +8226,7 @@ - (void)stopWithParams:(CHIPLevelControlClusterStopParams *)params completionHan new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9761,7 +8243,7 @@ - (void)stopWithOnOffWithCompletionHandler:(StatusCompletion)completionHandler new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9774,294 +8256,216 @@ new CHIPCommandSuccessCallbackBridge( - (void)readAttributeCurrentLevelWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = LevelControl::Attributes::CurrentLevel::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = LevelControl::Attributes::CurrentLevel::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeCurrentLevelWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCurrentLevel(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeCurrentLevelWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCurrentLevel(success); + using TypeInfo = LevelControl::Attributes::CurrentLevel::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeRemainingTimeWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = LevelControl::Attributes::RemainingTime::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = LevelControl::Attributes::RemainingTime::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeRemainingTimeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeRemainingTime(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeRemainingTimeWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeRemainingTime(success); + using TypeInfo = LevelControl::Attributes::RemainingTime::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeMinLevelWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = LevelControl::Attributes::MinLevel::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = LevelControl::Attributes::MinLevel::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeMinLevelWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMinLevel(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMinLevelWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMinLevel(success); + using TypeInfo = LevelControl::Attributes::MinLevel::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeMaxLevelWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = LevelControl::Attributes::MaxLevel::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = LevelControl::Attributes::MaxLevel::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeMaxLevelWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMaxLevel(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMaxLevelWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMaxLevel(success); + using TypeInfo = LevelControl::Attributes::MaxLevel::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeCurrentFrequencyWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = LevelControl::Attributes::CurrentFrequency::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = LevelControl::Attributes::CurrentFrequency::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeCurrentFrequencyWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCurrentFrequency(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeCurrentFrequencyWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCurrentFrequency(success); + using TypeInfo = LevelControl::Attributes::CurrentFrequency::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeMinFrequencyWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = LevelControl::Attributes::MinFrequency::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = LevelControl::Attributes::MinFrequency::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeMinFrequencyWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMinFrequency(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMinFrequencyWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMinFrequency(success); + using TypeInfo = LevelControl::Attributes::MinFrequency::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeMaxFrequencyWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = LevelControl::Attributes::MaxFrequency::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = LevelControl::Attributes::MaxFrequency::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeMaxFrequencyWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMaxFrequency(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMaxFrequencyWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMaxFrequency(success); + using TypeInfo = LevelControl::Attributes::MaxFrequency::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeOptionsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = LevelControl::Attributes::Options::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = LevelControl::Attributes::Options::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeOptionsWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10077,47 +8481,37 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeOptionsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeOptions(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeOptionsWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeOptions(success); + using TypeInfo = LevelControl::Attributes::Options::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeOnOffTransitionTimeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = LevelControl::Attributes::OnOffTransitionTime::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = LevelControl::Attributes::OnOffTransitionTime::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeOnOffTransitionTimeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10133,35 +8527,27 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeOnOffTransitionTimeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeOnOffTransitionTime(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeOnOffTransitionTimeWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeOnOffTransitionTime(success); + using TypeInfo = LevelControl::Attributes::OnOffTransitionTime::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeOnLevelWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = LevelControl::Attributes::OnLevel::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -10173,7 +8559,7 @@ - (void)writeAttributeOnLevelWithValue:(NSNumber * _Nullable)value completionHan { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10194,36 +8580,26 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeOnLevelWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt8uAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeOnLevel(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeOnLevelWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeOnLevel(success); + using TypeInfo = LevelControl::Attributes::OnLevel::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeOnTransitionTimeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = LevelControl::Attributes::OnTransitionTime::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -10235,7 +8611,7 @@ - (void)writeAttributeOnTransitionTimeWithValue:(NSNumber * _Nullable)value comp { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10256,37 +8632,27 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeOnTransitionTimeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt16uAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeOnTransitionTime(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeOnTransitionTimeWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeOnTransitionTime(success); + using TypeInfo = LevelControl::Attributes::OnTransitionTime::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeOffTransitionTimeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = LevelControl::Attributes::OffTransitionTime::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -10298,7 +8664,7 @@ - (void)writeAttributeOffTransitionTimeWithValue:(NSNumber * _Nullable)value com { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10319,37 +8685,27 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeOffTransitionTimeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt16uAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeOffTransitionTime(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeOffTransitionTimeWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeOffTransitionTime(success); + using TypeInfo = LevelControl::Attributes::OffTransitionTime::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeDefaultMoveRateWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = LevelControl::Attributes::DefaultMoveRate::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -10361,7 +8717,7 @@ - (void)writeAttributeDefaultMoveRateWithValue:(NSNumber * _Nullable)value compl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10382,49 +8738,38 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeDefaultMoveRateWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt8uAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeDefaultMoveRate(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeDefaultMoveRateWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPNullableInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeDefaultMoveRate(success); + using TypeInfo = LevelControl::Attributes::DefaultMoveRate::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeStartUpCurrentLevelWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = LevelControl::Attributes::StartUpCurrentLevel::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = LevelControl::Attributes::StartUpCurrentLevel::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeStartUpCurrentLevelWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10440,36 +8785,28 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeStartUpCurrentLevelWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeStartUpCurrentLevel(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeStartUpCurrentLevelWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeStartUpCurrentLevel(success); + using TypeInfo = LevelControl::Attributes::StartUpCurrentLevel::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPLevelControlAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = LevelControl::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -10480,40 +8817,30 @@ new CHIPLevelControlAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = LevelControl::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = LevelControl::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = LevelControl::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -10532,7 +8859,7 @@ - (void)sleepWithCompletionHandler:(StatusCompletion)completionHandler new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10546,11 +8873,7 @@ - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPLowPowerAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = LowPower::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -10561,40 +8884,30 @@ new CHIPLowPowerAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = LowPower::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = LowPower::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = LowPower::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -10613,7 +8926,7 @@ - (void)hideInputStatusWithCompletionHandler:(StatusCompletion)completionHandler new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10632,7 +8945,7 @@ - (void)renameInputWithParams:(CHIPMediaInputClusterRenameInputParams *)params c new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10650,7 +8963,7 @@ - (void)selectInputWithParams:(CHIPMediaInputClusterSelectInputParams *)params c new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10667,7 +8980,7 @@ - (void)showInputStatusWithCompletionHandler:(StatusCompletion)completionHandler new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10681,11 +8994,7 @@ - (void)readAttributeMediaInputListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPMediaInputMediaInputListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = MediaInput::Attributes::MediaInputList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -10693,54 +9002,59 @@ new CHIPMediaInputMediaInputListListAttributeCallbackBridge( }); } -- (void)readAttributeCurrentMediaInputWithCompletionHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))completionHandler +- (void)subscribeAttributeMediaInputListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, + new CHIPMediaInputMediaInputListListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = MediaInput::Attributes::CurrentMediaInput::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = MediaInput::Attributes::MediaInputList::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPMediaInputMediaInputListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); } -- (void)subscribeAttributeCurrentMediaInputWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)readAttributeCurrentMediaInputWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCurrentMediaInput(success, failure, minInterval, maxInterval); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = MediaInput::Attributes::CurrentMediaInput::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)reportAttributeCurrentMediaInputWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler +- (void)subscribeAttributeCurrentMediaInputWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCurrentMediaInput(success); + using TypeInfo = MediaInput::Attributes::CurrentMediaInput::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPMediaInputAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = MediaInput::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -10751,40 +9065,30 @@ new CHIPMediaInputAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = MediaInput::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = MediaInput::Attributes::ClusterRevision::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); -} - -- (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); - }, - true); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); } @end @@ -10803,11 +9107,7 @@ - (void)mediaFastForwardWithCompletionHandler:(void (^)(CHIPMediaPlaybackCluster MediaPlayback::Commands::MediaFastForward::Type request; new CHIPMediaPlaybackClusterMediaFastForwardResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -10821,11 +9121,7 @@ - (void)mediaNextWithCompletionHandler:(void (^)(CHIPMediaPlaybackClusterMediaNe MediaPlayback::Commands::MediaNext::Type request; new CHIPMediaPlaybackClusterMediaNextResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -10839,11 +9135,7 @@ - (void)mediaPauseWithCompletionHandler:(void (^)(CHIPMediaPlaybackClusterMediaP MediaPlayback::Commands::MediaPause::Type request; new CHIPMediaPlaybackClusterMediaPauseResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -10857,11 +9149,7 @@ - (void)mediaPlayWithCompletionHandler:(void (^)(CHIPMediaPlaybackClusterMediaPl MediaPlayback::Commands::MediaPlay::Type request; new CHIPMediaPlaybackClusterMediaPlayResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -10875,11 +9163,7 @@ - (void)mediaPreviousWithCompletionHandler:(void (^)(CHIPMediaPlaybackClusterMed MediaPlayback::Commands::MediaPrevious::Type request; new CHIPMediaPlaybackClusterMediaPreviousResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -10893,11 +9177,7 @@ - (void)mediaRewindWithCompletionHandler:(void (^)(CHIPMediaPlaybackClusterMedia MediaPlayback::Commands::MediaRewind::Type request; new CHIPMediaPlaybackClusterMediaRewindResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -10913,11 +9193,7 @@ - (void)mediaSeekWithParams:(CHIPMediaPlaybackClusterMediaSeekParams *)params request.position = params.position.unsignedLongLongValue; new CHIPMediaPlaybackClusterMediaSeekResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -10933,11 +9209,7 @@ - (void)mediaSkipBackwardWithParams:(CHIPMediaPlaybackClusterMediaSkipBackwardPa request.deltaPositionMilliseconds = params.deltaPositionMilliseconds.unsignedLongLongValue; new CHIPMediaPlaybackClusterMediaSkipBackwardResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -10953,11 +9225,7 @@ - (void)mediaSkipForwardWithParams:(CHIPMediaPlaybackClusterMediaSkipForwardPara request.deltaPositionMilliseconds = params.deltaPositionMilliseconds.unsignedLongLongValue; new CHIPMediaPlaybackClusterMediaSkipForwardResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -10971,11 +9239,7 @@ - (void)mediaStartOverWithCompletionHandler:(void (^)(CHIPMediaPlaybackClusterMe MediaPlayback::Commands::MediaStartOver::Type request; new CHIPMediaPlaybackClusterMediaStartOverResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -10989,11 +9253,7 @@ - (void)mediaStopWithCompletionHandler:(void (^)(CHIPMediaPlaybackClusterMediaSt MediaPlayback::Commands::MediaStop::Type request; new CHIPMediaPlaybackClusterMediaStopResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -11003,321 +9263,236 @@ new CHIPMediaPlaybackClusterMediaStopResponseCallbackBridge( - (void)readAttributePlaybackStateWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = MediaPlayback::Attributes::PlaybackState::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = MediaPlayback::Attributes::PlaybackState::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributePlaybackStateWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePlaybackState(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributePlaybackStateWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePlaybackState(success); + using TypeInfo = MediaPlayback::Attributes::PlaybackState::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeStartTimeWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = MediaPlayback::Attributes::StartTime::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = MediaPlayback::Attributes::StartTime::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeStartTimeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeStartTime(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeStartTimeWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeStartTime(success); + using TypeInfo = MediaPlayback::Attributes::StartTime::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeDurationWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = MediaPlayback::Attributes::Duration::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = MediaPlayback::Attributes::Duration::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeDurationWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeDuration(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeDurationWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeDuration(success); + using TypeInfo = MediaPlayback::Attributes::Duration::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributePositionUpdatedAtWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = MediaPlayback::Attributes::PositionUpdatedAt::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = MediaPlayback::Attributes::PositionUpdatedAt::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributePositionUpdatedAtWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePositionUpdatedAt(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributePositionUpdatedAtWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePositionUpdatedAt(success); + using TypeInfo = MediaPlayback::Attributes::PositionUpdatedAt::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributePositionWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = MediaPlayback::Attributes::Position::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = MediaPlayback::Attributes::Position::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributePositionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePosition(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributePositionWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePosition(success); + using TypeInfo = MediaPlayback::Attributes::Position::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributePlaybackSpeedWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = MediaPlayback::Attributes::PlaybackSpeed::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = MediaPlayback::Attributes::PlaybackSpeed::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributePlaybackSpeedWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePlaybackSpeed(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributePlaybackSpeedWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePlaybackSpeed(success); + using TypeInfo = MediaPlayback::Attributes::PlaybackSpeed::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeSeekRangeEndWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = MediaPlayback::Attributes::SeekRangeEnd::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = MediaPlayback::Attributes::SeekRangeEnd::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeSeekRangeEndWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeSeekRangeEnd(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeSeekRangeEndWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeSeekRangeEnd(success); + using TypeInfo = MediaPlayback::Attributes::SeekRangeEnd::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeSeekRangeStartWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = MediaPlayback::Attributes::SeekRangeStart::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = MediaPlayback::Attributes::SeekRangeStart::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeSeekRangeStartWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeSeekRangeStart(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeSeekRangeStartWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeSeekRangeStart(success); + using TypeInfo = MediaPlayback::Attributes::SeekRangeStart::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPMediaPlaybackAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = MediaPlayback::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -11328,40 +9503,30 @@ new CHIPMediaPlaybackAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = MediaPlayback::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = MediaPlayback::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = MediaPlayback::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -11382,7 +9547,7 @@ - (void)changeToModeWithParams:(CHIPModeSelectClusterChangeToModeParams *)params new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -11395,51 +9560,36 @@ new CHIPCommandSuccessCallbackBridge( - (void)readAttributeCurrentModeWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ModeSelect::Attributes::CurrentMode::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ModeSelect::Attributes::CurrentMode::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeCurrentModeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCurrentMode(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeCurrentModeWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCurrentMode(success); + using TypeInfo = ModeSelect::Attributes::CurrentMode::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeSupportedModesWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPModeSelectSupportedModesListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = ModeSelect::Attributes::SupportedModes::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -11447,26 +9597,40 @@ new CHIPModeSelectSupportedModesListAttributeCallbackBridge( }); } -- (void)readAttributeOnModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler +- (void)subscribeAttributeSupportedModesWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, + new CHIPModeSelectSupportedModesListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ModeSelect::Attributes::OnMode::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = ModeSelect::Attributes::SupportedModes::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPModeSelectSupportedModesListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); +} + +- (void)readAttributeOnModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler +{ + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ModeSelect::Attributes::OnMode::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeOnModeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -11482,113 +9646,82 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeOnModeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeOnMode(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeOnModeWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeOnMode(success); + using TypeInfo = ModeSelect::Attributes::OnMode::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeStartUpModeWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ModeSelect::Attributes::StartUpMode::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ModeSelect::Attributes::StartUpMode::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeStartUpModeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeStartUpMode(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeStartUpModeWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeStartUpMode(success); + using TypeInfo = ModeSelect::Attributes::StartUpMode::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeDescriptionWithCompletionHandler:(void (^)( NSString * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ModeSelect::Attributes::Description::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ModeSelect::Attributes::Description::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeDescriptionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeDescription(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeDescriptionWithResponseHandler:(void (^)( - NSString * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPCharStringAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeDescription(success); + using TypeInfo = ModeSelect::Attributes::Description::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPModeSelectAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = ModeSelect::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -11599,40 +9732,30 @@ new CHIPModeSelectAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ModeSelect::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ModeSelect::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = ModeSelect::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -11655,11 +9778,7 @@ - (void)addThreadNetworkWithParams:(CHIPNetworkCommissioningClusterAddThreadNetw request.timeoutMs = params.timeoutMs.unsignedIntValue; new CHIPNetworkCommissioningClusterAddThreadNetworkResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -11678,11 +9797,7 @@ - (void)addWiFiNetworkWithParams:(CHIPNetworkCommissioningClusterAddWiFiNetworkP request.timeoutMs = params.timeoutMs.unsignedIntValue; new CHIPNetworkCommissioningClusterAddWiFiNetworkResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -11700,11 +9815,7 @@ - (void)disableNetworkWithParams:(CHIPNetworkCommissioningClusterDisableNetworkP request.timeoutMs = params.timeoutMs.unsignedIntValue; new CHIPNetworkCommissioningClusterDisableNetworkResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -11722,11 +9833,7 @@ - (void)enableNetworkWithParams:(CHIPNetworkCommissioningClusterEnableNetworkPar request.timeoutMs = params.timeoutMs.unsignedIntValue; new CHIPNetworkCommissioningClusterEnableNetworkResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -11744,11 +9851,7 @@ - (void)removeNetworkWithParams:(CHIPNetworkCommissioningClusterRemoveNetworkPar request.timeoutMs = params.timeoutMs.unsignedIntValue; new CHIPNetworkCommissioningClusterRemoveNetworkResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -11766,11 +9869,7 @@ - (void)scanNetworksWithParams:(CHIPNetworkCommissioningClusterScanNetworksParam request.timeoutMs = params.timeoutMs.unsignedIntValue; new CHIPNetworkCommissioningClusterScanNetworksResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -11788,11 +9887,7 @@ - (void)updateThreadNetworkWithParams:(CHIPNetworkCommissioningClusterUpdateThre request.timeoutMs = params.timeoutMs.unsignedIntValue; new CHIPNetworkCommissioningClusterUpdateThreadNetworkResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -11812,11 +9907,7 @@ - (void)updateWiFiNetworkWithParams:(CHIPNetworkCommissioningClusterUpdateWiFiNe request.timeoutMs = params.timeoutMs.unsignedIntValue; new CHIPNetworkCommissioningClusterUpdateWiFiNetworkResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -11828,11 +9919,7 @@ - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNetworkCommissioningAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = NetworkCommissioning::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -11843,79 +9930,58 @@ new CHIPNetworkCommissioningAttributeListListAttributeCallbackBridge( - (void)readAttributeFeatureMapWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = NetworkCommissioning::Attributes::FeatureMap::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = NetworkCommissioning::Attributes::FeatureMap::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeFeatureMapWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeFeatureMap(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeFeatureMapWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeFeatureMap(success); + using TypeInfo = NetworkCommissioning::Attributes::FeatureMap::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = NetworkCommissioning::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = NetworkCommissioning::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = NetworkCommissioning::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -11937,11 +10003,7 @@ - (void)applyUpdateRequestWithParams:(CHIPOtaSoftwareUpdateProviderClusterApplyU request.newVersion = params.newVersion.unsignedIntValue; new CHIPOtaSoftwareUpdateProviderClusterApplyUpdateResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -11958,7 +10020,7 @@ - (void)notifyUpdateAppliedWithParams:(CHIPOtaSoftwareUpdateProviderClusterNotif new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -12018,11 +10080,7 @@ - (void)queryImageWithParams:(CHIPOtaSoftwareUpdateProviderClusterQueryImagePara } new CHIPOtaSoftwareUpdateProviderClusterQueryImageResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -12033,11 +10091,7 @@ - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPOtaSoftwareUpdateProviderAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = OtaSoftwareUpdateProvider::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -12048,40 +10102,30 @@ new CHIPOtaSoftwareUpdateProviderAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = OtaSoftwareUpdateProvider::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = OtaSoftwareUpdateProvider::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = OtaSoftwareUpdateProvider::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -12109,7 +10153,7 @@ - (void)announceOtaProviderWithParams:(CHIPOtaSoftwareUpdateRequestorClusterAnno new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -12123,11 +10167,7 @@ - (void)readAttributeDefaultOtaProviderWithCompletionHandler:(void (^)(NSData * NSError * _Nullable error))completionHandler { new CHIPOctetStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::DefaultOtaProvider::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -12139,7 +10179,7 @@ - (void)writeAttributeDefaultOtaProviderWithValue:(NSData * _Nonnull)value compl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -12155,75 +10195,56 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeDefaultOtaProviderWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPOctetStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeDefaultOtaProvider(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeDefaultOtaProviderWithResponseHandler:(void (^)(NSData * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPOctetStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPOctetStringAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeDefaultOtaProvider(success); + using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::DefaultOtaProvider::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPOctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeUpdatePossibleWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPBooleanAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdatePossible::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdatePossible::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeUpdatePossibleWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeUpdatePossible(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeUpdatePossibleWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPBooleanAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPBooleanAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeUpdatePossible(success); + using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdatePossible::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPOtaSoftwareUpdateRequestorAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -12234,40 +10255,30 @@ new CHIPOtaSoftwareUpdateRequestorAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -12282,128 +10293,96 @@ @implementation CHIPOccupancySensing - (void)readAttributeOccupancyWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = OccupancySensing::Attributes::Occupancy::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = OccupancySensing::Attributes::Occupancy::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeOccupancyWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeOccupancy(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeOccupancyWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeOccupancy(success); + using TypeInfo = OccupancySensing::Attributes::Occupancy::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeOccupancySensorTypeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = OccupancySensing::Attributes::OccupancySensorType::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = OccupancySensing::Attributes::OccupancySensorType::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeOccupancySensorTypeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeOccupancySensorType(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeOccupancySensorTypeWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeOccupancySensorType(success); + using TypeInfo = OccupancySensing::Attributes::OccupancySensorType::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeOccupancySensorTypeBitmapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = OccupancySensing::Attributes::OccupancySensorTypeBitmap::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = OccupancySensing::Attributes::OccupancySensorTypeBitmap::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeOccupancySensorTypeBitmapWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeOccupancySensorTypeBitmap(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeOccupancySensorTypeBitmapWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeOccupancySensorTypeBitmap(success); + using TypeInfo = OccupancySensing::Attributes::OccupancySensorTypeBitmap::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPOccupancySensingAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = OccupancySensing::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -12414,40 +10393,30 @@ new CHIPOccupancySensingAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = OccupancySensing::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = OccupancySensing::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = OccupancySensing::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -12466,7 +10435,7 @@ - (void)offWithCompletionHandler:(StatusCompletion)completionHandler new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -12486,7 +10455,7 @@ - (void)offWithEffectWithParams:(CHIPOnOffClusterOffWithEffectParams *)params co new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -12503,7 +10472,7 @@ - (void)onWithCompletionHandler:(StatusCompletion)completionHandler new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -12520,7 +10489,7 @@ - (void)onWithRecallGlobalSceneWithCompletionHandler:(StatusCompletion)completio new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -12542,7 +10511,7 @@ - (void)onWithTimedOffWithParams:(CHIPOnOffClusterOnWithTimedOffParams *)params new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -12559,7 +10528,7 @@ - (void)toggleWithCompletionHandler:(StatusCompletion)completionHandler new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -12571,100 +10540,75 @@ new CHIPCommandSuccessCallbackBridge( - (void)readAttributeOnOffWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPBooleanAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = OnOff::Attributes::OnOff::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = OnOff::Attributes::OnOff::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeOnOffWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeOnOff(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeOnOffWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPBooleanAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPBooleanAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeOnOff(success); + using TypeInfo = OnOff::Attributes::OnOff::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeGlobalSceneControlWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPBooleanAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = OnOff::Attributes::GlobalSceneControl::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = OnOff::Attributes::GlobalSceneControl::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeGlobalSceneControlWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeGlobalSceneControl(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeGlobalSceneControlWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPBooleanAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPBooleanAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeGlobalSceneControl(success); + using TypeInfo = OnOff::Attributes::GlobalSceneControl::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeOnTimeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = OnOff::Attributes::OnTime::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = OnOff::Attributes::OnTime::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeOnTimeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -12680,47 +10624,37 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeOnTimeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeOnTime(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeOnTimeWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeOnTime(success); + using TypeInfo = OnOff::Attributes::OnTime::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeOffWaitTimeWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = OnOff::Attributes::OffWaitTime::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = OnOff::Attributes::OffWaitTime::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeOffWaitTimeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -12736,48 +10670,37 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeOffWaitTimeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeOffWaitTime(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeOffWaitTimeWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeOffWaitTime(success); + using TypeInfo = OnOff::Attributes::OffWaitTime::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeStartUpOnOffWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = OnOff::Attributes::StartUpOnOff::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = OnOff::Attributes::StartUpOnOff::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeStartUpOnOffWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -12793,36 +10716,26 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeStartUpOnOffWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeStartUpOnOff(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeStartUpOnOffWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeStartUpOnOff(success); + using TypeInfo = OnOff::Attributes::StartUpOnOff::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPOnOffAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = OnOff::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -12833,79 +10746,58 @@ new CHIPOnOffAttributeListListAttributeCallbackBridge( - (void)readAttributeFeatureMapWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = OnOff::Attributes::FeatureMap::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = OnOff::Attributes::FeatureMap::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeFeatureMapWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeFeatureMap(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeFeatureMapWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeFeatureMap(success); + using TypeInfo = OnOff::Attributes::FeatureMap::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = OnOff::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = OnOff::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = OnOff::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -12920,63 +10812,47 @@ @implementation CHIPOnOffSwitchConfiguration - (void)readAttributeSwitchTypeWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = OnOffSwitchConfiguration::Attributes::SwitchType::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = OnOffSwitchConfiguration::Attributes::SwitchType::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeSwitchTypeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeSwitchType(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeSwitchTypeWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeSwitchType(success); + using TypeInfo = OnOffSwitchConfiguration::Attributes::SwitchType::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeSwitchActionsWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = OnOffSwitchConfiguration::Attributes::SwitchActions::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = OnOffSwitchConfiguration::Attributes::SwitchActions::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeSwitchActionsWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -12992,36 +10868,27 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeSwitchActionsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeSwitchActions(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeSwitchActionsWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeSwitchActions(success); + using TypeInfo = OnOffSwitchConfiguration::Attributes::SwitchActions::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPOnOffSwitchConfigurationAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = OnOffSwitchConfiguration::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -13032,40 +10899,30 @@ new CHIPOnOffSwitchConfigurationAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = OnOffSwitchConfiguration::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = OnOffSwitchConfiguration::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = OnOffSwitchConfiguration::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -13093,11 +10950,7 @@ - (void)addNOCWithParams:(CHIPOperationalCredentialsClusterAddNOCParams *)params request.adminVendorId = params.adminVendorId.unsignedShortValue; new CHIPOperationalCredentialsClusterNOCResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -13113,7 +10966,7 @@ - (void)addTrustedRootCertificateWithParams:(CHIPOperationalCredentialsClusterAd new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -13132,11 +10985,7 @@ - (void)attestationRequestWithParams:(CHIPOperationalCredentialsClusterAttestati request.attestationNonce = [self asByteSpan:params.attestationNonce]; new CHIPOperationalCredentialsClusterAttestationResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -13153,11 +11002,7 @@ - (void)certificateChainRequestWithParams:(CHIPOperationalCredentialsClusterCert request.certificateType = params.certificateType.unsignedCharValue; new CHIPOperationalCredentialsClusterCertificateChainResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -13174,11 +11019,7 @@ - (void)opCSRRequestWithParams:(CHIPOperationalCredentialsClusterOpCSRRequestPar request.CSRNonce = [self asByteSpan:params.csrNonce]; new CHIPOperationalCredentialsClusterOpCSRResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -13194,11 +11035,7 @@ - (void)removeFabricWithParams:(CHIPOperationalCredentialsClusterRemoveFabricPar request.fabricIndex = params.fabricIndex.unsignedCharValue; new CHIPOperationalCredentialsClusterNOCResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -13214,7 +11051,7 @@ - (void)removeTrustedRootCertificateWithParams:(CHIPOperationalCredentialsCluste new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -13233,11 +11070,7 @@ - (void)updateFabricLabelWithParams:(CHIPOperationalCredentialsClusterUpdateFabr request.label = [self asCharSpan:params.label]; new CHIPOperationalCredentialsClusterNOCResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -13257,11 +11090,7 @@ - (void)updateNOCWithParams:(CHIPOperationalCredentialsClusterUpdateNOCParams *) } new CHIPOperationalCredentialsClusterNOCResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -13272,11 +11101,7 @@ - (void)readAttributeFabricsListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPOperationalCredentialsFabricsListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = OperationalCredentials::Attributes::FabricsList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -13284,93 +11109,88 @@ new CHIPOperationalCredentialsFabricsListListAttributeCallbackBridge( }); } -- (void)readAttributeSupportedFabricsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))completionHandler +- (void)subscribeAttributeFabricsListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, + new CHIPOperationalCredentialsFabricsListListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = OperationalCredentials::Attributes::SupportedFabrics::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = OperationalCredentials::Attributes::FabricsList::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPOperationalCredentialsFabricsListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); } -- (void)subscribeAttributeSupportedFabricsWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)readAttributeSupportedFabricsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeSupportedFabrics(success, failure, minInterval, maxInterval); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = OperationalCredentials::Attributes::SupportedFabrics::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)reportAttributeSupportedFabricsWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler +- (void)subscribeAttributeSupportedFabricsWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeSupportedFabrics(success); + using TypeInfo = OperationalCredentials::Attributes::SupportedFabrics::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeCommissionedFabricsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = OperationalCredentials::Attributes::CommissionedFabrics::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = OperationalCredentials::Attributes::CommissionedFabrics::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeCommissionedFabricsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCommissionedFabrics(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeCommissionedFabricsWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCommissionedFabrics(success); + using TypeInfo = OperationalCredentials::Attributes::CommissionedFabrics::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeTrustedRootCertificatesWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPOperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = OperationalCredentials::Attributes::TrustedRootCertificates::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -13378,54 +11198,61 @@ new CHIPOperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge }); } -- (void)readAttributeCurrentFabricIndexWithCompletionHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))completionHandler +- (void)subscribeAttributeTrustedRootCertificatesWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, + new CHIPOperationalCredentialsTrustedRootCertificatesListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = OperationalCredentials::Attributes::CurrentFabricIndex::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = OperationalCredentials::Attributes::TrustedRootCertificates::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPOperationalCredentialsTrustedRootCertificatesListAttributeCallbackSubscriptionBridge:: + OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); } -- (void)subscribeAttributeCurrentFabricIndexWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)readAttributeCurrentFabricIndexWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCurrentFabricIndex(success, failure, minInterval, maxInterval); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = OperationalCredentials::Attributes::CurrentFabricIndex::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)reportAttributeCurrentFabricIndexWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler +- (void)subscribeAttributeCurrentFabricIndexWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCurrentFabricIndex(success); + using TypeInfo = OperationalCredentials::Attributes::CurrentFabricIndex::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPOperationalCredentialsAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = OperationalCredentials::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -13436,40 +11263,30 @@ new CHIPOperationalCredentialsAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = OperationalCredentials::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = OperationalCredentials::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = OperationalCredentials::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -13483,282 +11300,209 @@ @implementation CHIPPowerSource - (void)readAttributeStatusWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PowerSource::Attributes::Status::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PowerSource::Attributes::Status::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeStatusWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeStatus(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeStatusWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeStatus(success); + using TypeInfo = PowerSource::Attributes::Status::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeOrderWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PowerSource::Attributes::Order::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PowerSource::Attributes::Order::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeOrderWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeOrder(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeOrderWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeOrder(success); + using TypeInfo = PowerSource::Attributes::Order::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeDescriptionWithCompletionHandler:(void (^)( NSString * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PowerSource::Attributes::Description::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PowerSource::Attributes::Description::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeDescriptionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeDescription(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeDescriptionWithResponseHandler:(void (^)( - NSString * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPCharStringAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeDescription(success); + using TypeInfo = PowerSource::Attributes::Description::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeBatteryVoltageWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PowerSource::Attributes::BatteryVoltage::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PowerSource::Attributes::BatteryVoltage::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeBatteryVoltageWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeBatteryVoltage(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeBatteryVoltageWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeBatteryVoltage(success); + using TypeInfo = PowerSource::Attributes::BatteryVoltage::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeBatteryPercentRemainingWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PowerSource::Attributes::BatteryPercentRemaining::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PowerSource::Attributes::BatteryPercentRemaining::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeBatteryPercentRemainingWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeBatteryPercentRemaining(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeBatteryPercentRemainingWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeBatteryPercentRemaining(success); + using TypeInfo = PowerSource::Attributes::BatteryPercentRemaining::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeBatteryTimeRemainingWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PowerSource::Attributes::BatteryTimeRemaining::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PowerSource::Attributes::BatteryTimeRemaining::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeBatteryTimeRemainingWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeBatteryTimeRemaining(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeBatteryTimeRemainingWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeBatteryTimeRemaining(success); + using TypeInfo = PowerSource::Attributes::BatteryTimeRemaining::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeBatteryChargeLevelWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PowerSource::Attributes::BatteryChargeLevel::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PowerSource::Attributes::BatteryChargeLevel::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeBatteryChargeLevelWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeBatteryChargeLevel(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeBatteryChargeLevelWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeBatteryChargeLevel(success); + using TypeInfo = PowerSource::Attributes::BatteryChargeLevel::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeActiveBatteryFaultsWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPPowerSourceActiveBatteryFaultsListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = PowerSource::Attributes::ActiveBatteryFaults::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -13766,54 +11510,60 @@ new CHIPPowerSourceActiveBatteryFaultsListAttributeCallbackBridge( }); } -- (void)readAttributeBatteryChargeStateWithCompletionHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))completionHandler +- (void)subscribeAttributeActiveBatteryFaultsWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, + new CHIPPowerSourceActiveBatteryFaultsListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PowerSource::Attributes::BatteryChargeState::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = PowerSource::Attributes::ActiveBatteryFaults::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPPowerSourceActiveBatteryFaultsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); } -- (void)subscribeAttributeBatteryChargeStateWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)readAttributeBatteryChargeStateWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeBatteryChargeState(success, failure, minInterval, maxInterval); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PowerSource::Attributes::BatteryChargeState::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)reportAttributeBatteryChargeStateWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler +- (void)subscribeAttributeBatteryChargeStateWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeBatteryChargeState(success); + using TypeInfo = PowerSource::Attributes::BatteryChargeState::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPPowerSourceAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = PowerSource::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -13824,79 +11574,58 @@ new CHIPPowerSourceAttributeListListAttributeCallbackBridge( - (void)readAttributeFeatureMapWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PowerSource::Attributes::FeatureMap::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PowerSource::Attributes::FeatureMap::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeFeatureMapWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeFeatureMap(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeFeatureMapWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeFeatureMap(success); + using TypeInfo = PowerSource::Attributes::FeatureMap::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PowerSource::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PowerSource::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = PowerSource::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -13911,11 +11640,7 @@ @implementation CHIPPowerSourceConfiguration - (void)readAttributeSourcesWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPPowerSourceConfigurationSourcesListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = PowerSourceConfiguration::Attributes::Sources::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -13927,11 +11652,7 @@ - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPPowerSourceConfigurationAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = PowerSourceConfiguration::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -13942,17 +11663,12 @@ new CHIPPowerSourceConfigurationAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PowerSourceConfiguration::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PowerSourceConfiguration::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } @end @@ -13967,129 +11683,95 @@ @implementation CHIPPressureMeasurement - (void)readAttributeMeasuredValueWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PressureMeasurement::Attributes::MeasuredValue::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PressureMeasurement::Attributes::MeasuredValue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMeasuredValue(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMeasuredValueWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMeasuredValue(success); + using TypeInfo = PressureMeasurement::Attributes::MeasuredValue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeMinMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PressureMeasurement::Attributes::MinMeasuredValue::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PressureMeasurement::Attributes::MinMeasuredValue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeMinMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMinMeasuredValue(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMinMeasuredValueWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMinMeasuredValue(success); + using TypeInfo = PressureMeasurement::Attributes::MinMeasuredValue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeMaxMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PressureMeasurement::Attributes::MaxMeasuredValue::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PressureMeasurement::Attributes::MaxMeasuredValue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeMaxMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMaxMeasuredValue(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMaxMeasuredValueWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMaxMeasuredValue(success); + using TypeInfo = PressureMeasurement::Attributes::MaxMeasuredValue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPPressureMeasurementAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = PressureMeasurement::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -14100,40 +11782,30 @@ new CHIPPressureMeasurementAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PressureMeasurement::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PressureMeasurement::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = PressureMeasurement::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -14148,708 +11820,520 @@ @implementation CHIPPumpConfigurationAndControl - (void)readAttributeMaxPressureWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PumpConfigurationAndControl::Attributes::MaxPressure::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PumpConfigurationAndControl::Attributes::MaxPressure::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeMaxPressureWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMaxPressure(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMaxPressureWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMaxPressure(success); + using TypeInfo = PumpConfigurationAndControl::Attributes::MaxPressure::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeMaxSpeedWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PumpConfigurationAndControl::Attributes::MaxSpeed::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PumpConfigurationAndControl::Attributes::MaxSpeed::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeMaxSpeedWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMaxSpeed(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMaxSpeedWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMaxSpeed(success); + using TypeInfo = PumpConfigurationAndControl::Attributes::MaxSpeed::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeMaxFlowWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PumpConfigurationAndControl::Attributes::MaxFlow::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PumpConfigurationAndControl::Attributes::MaxFlow::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeMaxFlowWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMaxFlow(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMaxFlowWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMaxFlow(success); + using TypeInfo = PumpConfigurationAndControl::Attributes::MaxFlow::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeMinConstPressureWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstPressure::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstPressure::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeMinConstPressureWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMinConstPressure(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMinConstPressureWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMinConstPressure(success); + using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstPressure::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeMaxConstPressureWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstPressure::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstPressure::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeMaxConstPressureWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMaxConstPressure(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMaxConstPressureWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMaxConstPressure(success); + using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstPressure::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeMinCompPressureWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PumpConfigurationAndControl::Attributes::MinCompPressure::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PumpConfigurationAndControl::Attributes::MinCompPressure::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeMinCompPressureWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMinCompPressure(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMinCompPressureWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMinCompPressure(success); + using TypeInfo = PumpConfigurationAndControl::Attributes::MinCompPressure::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeMaxCompPressureWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PumpConfigurationAndControl::Attributes::MaxCompPressure::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PumpConfigurationAndControl::Attributes::MaxCompPressure::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeMaxCompPressureWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMaxCompPressure(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMaxCompPressureWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMaxCompPressure(success); + using TypeInfo = PumpConfigurationAndControl::Attributes::MaxCompPressure::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeMinConstSpeedWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstSpeed::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstSpeed::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeMinConstSpeedWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMinConstSpeed(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMinConstSpeedWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMinConstSpeed(success); + using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstSpeed::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeMaxConstSpeedWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstSpeed::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstSpeed::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeMaxConstSpeedWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMaxConstSpeed(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMaxConstSpeedWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMaxConstSpeed(success); + using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstSpeed::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeMinConstFlowWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstFlow::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstFlow::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeMinConstFlowWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMinConstFlow(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMinConstFlowWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMinConstFlow(success); + using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstFlow::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeMaxConstFlowWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstFlow::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstFlow::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeMaxConstFlowWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMaxConstFlow(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMaxConstFlowWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMaxConstFlow(success); + using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstFlow::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeMinConstTempWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstTemp::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstTemp::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeMinConstTempWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMinConstTemp(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMinConstTempWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMinConstTemp(success); + using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstTemp::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeMaxConstTempWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstTemp::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstTemp::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeMaxConstTempWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMaxConstTemp(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMaxConstTempWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMaxConstTemp(success); + using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstTemp::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributePumpStatusWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PumpConfigurationAndControl::Attributes::PumpStatus::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PumpConfigurationAndControl::Attributes::PumpStatus::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributePumpStatusWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePumpStatus(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributePumpStatusWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePumpStatus(success); + using TypeInfo = PumpConfigurationAndControl::Attributes::PumpStatus::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeEffectiveOperationModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PumpConfigurationAndControl::Attributes::EffectiveOperationMode::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PumpConfigurationAndControl::Attributes::EffectiveOperationMode::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeEffectiveOperationModeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeEffectiveOperationMode(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeEffectiveOperationModeWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeEffectiveOperationMode(success); + using TypeInfo = PumpConfigurationAndControl::Attributes::EffectiveOperationMode::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeEffectiveControlModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PumpConfigurationAndControl::Attributes::EffectiveControlMode::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PumpConfigurationAndControl::Attributes::EffectiveControlMode::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeEffectiveControlModeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeEffectiveControlMode(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeEffectiveControlModeWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeEffectiveControlMode(success); + using TypeInfo = PumpConfigurationAndControl::Attributes::EffectiveControlMode::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeCapacityWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PumpConfigurationAndControl::Attributes::Capacity::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PumpConfigurationAndControl::Attributes::Capacity::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeCapacityWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCapacity(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeCapacityWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCapacity(success); + using TypeInfo = PumpConfigurationAndControl::Attributes::Capacity::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeSpeedWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PumpConfigurationAndControl::Attributes::Speed::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PumpConfigurationAndControl::Attributes::Speed::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeSpeedWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeSpeed(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeSpeedWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeSpeed(success); + using TypeInfo = PumpConfigurationAndControl::Attributes::Speed::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeLifetimeRunningHoursWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeRunningHours::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -14862,7 +12346,7 @@ - (void)writeAttributeLifetimeRunningHoursWithValue:(NSNumber * _Nullable)value { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -14883,74 +12367,55 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeLifetimeRunningHoursWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt32uAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeLifetimeRunningHours(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeLifetimeRunningHoursWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeLifetimeRunningHours(success); + using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeRunningHours::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributePowerWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PumpConfigurationAndControl::Attributes::Power::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PumpConfigurationAndControl::Attributes::Power::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributePowerWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePower(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributePowerWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePower(success); + using TypeInfo = PumpConfigurationAndControl::Attributes::Power::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeLifetimeEnergyConsumedWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeEnergyConsumed::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -14963,7 +12428,7 @@ - (void)writeAttributeLifetimeEnergyConsumedWithValue:(NSNumber * _Nullable)valu { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -14984,49 +12449,39 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeLifetimeEnergyConsumedWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt32uAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeLifetimeEnergyConsumed(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeLifetimeEnergyConsumedWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeLifetimeEnergyConsumed(success); + using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeEnergyConsumed::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeOperationModeWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PumpConfigurationAndControl::Attributes::OperationMode::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PumpConfigurationAndControl::Attributes::OperationMode::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeOperationModeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -15042,48 +12497,38 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeOperationModeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeOperationMode(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeOperationModeWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeOperationMode(success); + using TypeInfo = PumpConfigurationAndControl::Attributes::OperationMode::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeControlModeWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PumpConfigurationAndControl::Attributes::ControlMode::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PumpConfigurationAndControl::Attributes::ControlMode::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeControlModeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -15099,74 +12544,54 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeControlModeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeControlMode(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeControlModeWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeControlMode(success); + using TypeInfo = PumpConfigurationAndControl::Attributes::ControlMode::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAlarmMaskWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PumpConfigurationAndControl::Attributes::AlarmMask::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PumpConfigurationAndControl::Attributes::AlarmMask::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeAlarmMaskWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeAlarmMask(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeAlarmMaskWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeAlarmMask(success); + using TypeInfo = PumpConfigurationAndControl::Attributes::AlarmMask::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPPumpConfigurationAndControlAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = PumpConfigurationAndControl::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -15177,79 +12602,58 @@ new CHIPPumpConfigurationAndControlAttributeListListAttributeCallbackBridge( - (void)readAttributeFeatureMapWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PumpConfigurationAndControl::Attributes::FeatureMap::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PumpConfigurationAndControl::Attributes::FeatureMap::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeFeatureMapWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeFeatureMap(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeFeatureMapWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeFeatureMap(success); + using TypeInfo = PumpConfigurationAndControl::Attributes::FeatureMap::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = PumpConfigurationAndControl::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = PumpConfigurationAndControl::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = PumpConfigurationAndControl::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -15264,167 +12668,123 @@ @implementation CHIPRelativeHumidityMeasurement - (void)readAttributeMeasuredValueWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = RelativeHumidityMeasurement::Attributes::MeasuredValue::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = RelativeHumidityMeasurement::Attributes::MeasuredValue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMeasuredValue(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMeasuredValueWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMeasuredValue(success); + using TypeInfo = RelativeHumidityMeasurement::Attributes::MeasuredValue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeMinMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = RelativeHumidityMeasurement::Attributes::MinMeasuredValue::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = RelativeHumidityMeasurement::Attributes::MinMeasuredValue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeMinMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMinMeasuredValue(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMinMeasuredValueWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMinMeasuredValue(success); + using TypeInfo = RelativeHumidityMeasurement::Attributes::MinMeasuredValue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeMaxMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = RelativeHumidityMeasurement::Attributes::MaxMeasuredValue::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = RelativeHumidityMeasurement::Attributes::MaxMeasuredValue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeMaxMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMaxMeasuredValue(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMaxMeasuredValueWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler -{ - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMaxMeasuredValue(success); + using TypeInfo = RelativeHumidityMeasurement::Attributes::MaxMeasuredValue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeToleranceWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = RelativeHumidityMeasurement::Attributes::Tolerance::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = RelativeHumidityMeasurement::Attributes::Tolerance::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeToleranceWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeTolerance(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeToleranceWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeTolerance(success); + using TypeInfo = RelativeHumidityMeasurement::Attributes::Tolerance::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPRelativeHumidityMeasurementAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = RelativeHumidityMeasurement::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -15435,40 +12795,30 @@ new CHIPRelativeHumidityMeasurementAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = RelativeHumidityMeasurement::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = RelativeHumidityMeasurement::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = RelativeHumidityMeasurement::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -15516,11 +12866,7 @@ - (void)addSceneWithParams:(CHIPScenesClusterAddSceneParams *)params } new CHIPScenesClusterAddSceneResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -15536,11 +12882,7 @@ - (void)getSceneMembershipWithParams:(CHIPScenesClusterGetSceneMembershipParams request.groupId = params.groupId.unsignedShortValue; new CHIPScenesClusterGetSceneMembershipResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -15557,7 +12899,7 @@ - (void)recallSceneWithParams:(CHIPScenesClusterRecallSceneParams *)params compl new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -15576,11 +12918,7 @@ - (void)removeAllScenesWithParams:(CHIPScenesClusterRemoveAllScenesParams *)para request.groupId = params.groupId.unsignedShortValue; new CHIPScenesClusterRemoveAllScenesResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -15597,11 +12935,7 @@ - (void)removeSceneWithParams:(CHIPScenesClusterRemoveSceneParams *)params request.sceneId = params.sceneId.unsignedCharValue; new CHIPScenesClusterRemoveSceneResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -15618,11 +12952,7 @@ - (void)storeSceneWithParams:(CHIPScenesClusterStoreSceneParams *)params request.sceneId = params.sceneId.unsignedCharValue; new CHIPScenesClusterStoreSceneResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -15639,11 +12969,7 @@ - (void)viewSceneWithParams:(CHIPScenesClusterViewSceneParams *)params request.sceneId = params.sceneId.unsignedCharValue; new CHIPScenesClusterViewSceneResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -15653,207 +12979,148 @@ new CHIPScenesClusterViewSceneResponseCallbackBridge( - (void)readAttributeSceneCountWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Scenes::Attributes::SceneCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Scenes::Attributes::SceneCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeSceneCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeSceneCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeSceneCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeSceneCount(success); + using TypeInfo = Scenes::Attributes::SceneCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeCurrentSceneWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Scenes::Attributes::CurrentScene::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Scenes::Attributes::CurrentScene::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeCurrentSceneWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCurrentScene(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeCurrentSceneWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCurrentScene(success); + using TypeInfo = Scenes::Attributes::CurrentScene::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeCurrentGroupWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Scenes::Attributes::CurrentGroup::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Scenes::Attributes::CurrentGroup::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeCurrentGroupWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCurrentGroup(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeCurrentGroupWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCurrentGroup(success); + using TypeInfo = Scenes::Attributes::CurrentGroup::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeSceneValidWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPBooleanAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Scenes::Attributes::SceneValid::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Scenes::Attributes::SceneValid::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeSceneValidWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeSceneValid(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeSceneValidWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPBooleanAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPBooleanAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeSceneValid(success); + using TypeInfo = Scenes::Attributes::SceneValid::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNameSupportWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Scenes::Attributes::NameSupport::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Scenes::Attributes::NameSupport::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeNameSupportWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNameSupport(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNameSupportWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNameSupport(success); + using TypeInfo = Scenes::Attributes::NameSupport::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPScenesAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = Scenes::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -15864,40 +13131,30 @@ new CHIPScenesAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Scenes::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Scenes::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); - }, - true); + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Scenes::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); } @end @@ -15916,7 +13173,7 @@ - (void)resetWatermarksWithCompletionHandler:(StatusCompletion)completionHandler new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -15930,11 +13187,7 @@ - (void)readAttributeThreadMetricsWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPSoftwareDiagnosticsThreadMetricsListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = SoftwareDiagnostics::Attributes::ThreadMetrics::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -15942,132 +13195,117 @@ new CHIPSoftwareDiagnosticsThreadMetricsListAttributeCallbackBridge( }); } -- (void)readAttributeCurrentHeapFreeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))completionHandler +- (void)subscribeAttributeThreadMetricsWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, + new CHIPSoftwareDiagnosticsThreadMetricsListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapFree::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = SoftwareDiagnostics::Attributes::ThreadMetrics::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPSoftwareDiagnosticsThreadMetricsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); } -- (void)subscribeAttributeCurrentHeapFreeWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)readAttributeCurrentHeapFreeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler { - new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCurrentHeapFree(success, failure, minInterval, maxInterval); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapFree::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)reportAttributeCurrentHeapFreeWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +- (void)subscribeAttributeCurrentHeapFreeWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCurrentHeapFree(success); + using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapFree::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeCurrentHeapUsedWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapUsed::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapUsed::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeCurrentHeapUsedWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCurrentHeapUsed(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeCurrentHeapUsedWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCurrentHeapUsed(success); + using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapUsed::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeCurrentHeapHighWatermarkWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapHighWatermark::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapHighWatermark::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeCurrentHeapHighWatermarkWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCurrentHeapHighWatermark(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeCurrentHeapHighWatermarkWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCurrentHeapHighWatermark(success); + using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapHighWatermark::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPSoftwareDiagnosticsAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = SoftwareDiagnostics::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -16078,56 +13316,41 @@ new CHIPSoftwareDiagnosticsAttributeListListAttributeCallbackBridge( - (void)readAttributeFeatureMapWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = SoftwareDiagnostics::Attributes::FeatureMap::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = SoftwareDiagnostics::Attributes::FeatureMap::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = SoftwareDiagnostics::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = SoftwareDiagnostics::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = SoftwareDiagnostics::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -16142,129 +13365,95 @@ @implementation CHIPSwitch - (void)readAttributeNumberOfPositionsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Switch::Attributes::NumberOfPositions::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Switch::Attributes::NumberOfPositions::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeNumberOfPositionsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNumberOfPositions(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNumberOfPositionsWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNumberOfPositions(success); + using TypeInfo = Switch::Attributes::NumberOfPositions::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeCurrentPositionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Switch::Attributes::CurrentPosition::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Switch::Attributes::CurrentPosition::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeCurrentPositionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCurrentPosition(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeCurrentPositionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCurrentPosition(success); + using TypeInfo = Switch::Attributes::CurrentPosition::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeMultiPressMaxWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Switch::Attributes::MultiPressMax::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Switch::Attributes::MultiPressMax::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeMultiPressMaxWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMultiPressMax(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMultiPressMaxWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMultiPressMax(success); + using TypeInfo = Switch::Attributes::MultiPressMax::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPSwitchAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = Switch::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -16275,79 +13464,58 @@ new CHIPSwitchAttributeListListAttributeCallbackBridge( - (void)readAttributeFeatureMapWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Switch::Attributes::FeatureMap::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Switch::Attributes::FeatureMap::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeFeatureMapWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeFeatureMap(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeFeatureMapWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeFeatureMap(success); + using TypeInfo = Switch::Attributes::FeatureMap::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Switch::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Switch::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = Switch::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -16368,11 +13536,7 @@ - (void)changeChannelWithParams:(CHIPTvChannelClusterChangeChannelParams *)param request.match = [self asCharSpan:params.match]; new CHIPTvChannelClusterChangeChannelResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -16389,7 +13553,7 @@ - (void)changeChannelByNumberWithParams:(CHIPTvChannelClusterChangeChannelByNumb new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -16407,7 +13571,7 @@ - (void)skipChannelWithParams:(CHIPTvChannelClusterSkipChannelParams *)params co new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -16421,11 +13585,7 @@ - (void)readAttributeTvChannelListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPTvChannelTvChannelListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TvChannel::Attributes::TvChannelList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -16433,15 +13593,29 @@ new CHIPTvChannelTvChannelListListAttributeCallbackBridge( }); } +- (void)subscribeAttributeTvChannelListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + new CHIPTvChannelTvChannelListListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TvChannel::Attributes::TvChannelList::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPTvChannelTvChannelListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); +} + - (void)readAttributeTvChannelLineupWithCompletionHandler:(void (^)( NSData * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPOctetStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TvChannel::Attributes::TvChannelLineup::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -16451,36 +13625,27 @@ new CHIPOctetStringAttributeCallbackBridge( - (void)subscribeAttributeTvChannelLineupWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPOctetStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeTvChannelLineup(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeTvChannelLineupWithResponseHandler:(void (^)( - NSData * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPOctetStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPOctetStringAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeTvChannelLineup(success); + using TypeInfo = TvChannel::Attributes::TvChannelLineup::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPOctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeCurrentTvChannelWithCompletionHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPOctetStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TvChannel::Attributes::CurrentTvChannel::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -16490,36 +13655,27 @@ new CHIPOctetStringAttributeCallbackBridge( - (void)subscribeAttributeCurrentTvChannelWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPOctetStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCurrentTvChannel(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeCurrentTvChannelWithResponseHandler:(void (^)( - NSData * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPOctetStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPOctetStringAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCurrentTvChannel(success); + using TypeInfo = TvChannel::Attributes::CurrentTvChannel::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPOctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPTvChannelAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TvChannel::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -16530,40 +13686,30 @@ new CHIPTvChannelAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TvChannel::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TvChannel::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = TvChannel::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -16585,11 +13731,7 @@ - (void)navigateTargetWithParams:(CHIPTargetNavigatorClusterNavigateTargetParams request.data = [self asCharSpan:params.data]; new CHIPTargetNavigatorClusterNavigateTargetResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -16600,11 +13742,7 @@ - (void)readAttributeTargetNavigatorListWithCompletionHandler:(void (^)(NSArray NSError * _Nullable error))completionHandler { new CHIPTargetNavigatorTargetNavigatorListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TargetNavigator::Attributes::TargetNavigatorList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -16612,15 +13750,31 @@ new CHIPTargetNavigatorTargetNavigatorListListAttributeCallbackBridge( }); } +- (void)subscribeAttributeTargetNavigatorListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + new CHIPTargetNavigatorTargetNavigatorListListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TargetNavigator::Attributes::TargetNavigatorList::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPTargetNavigatorTargetNavigatorListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); +} + - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPTargetNavigatorAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TargetNavigator::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -16631,40 +13785,30 @@ new CHIPTargetNavigatorAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TargetNavigator::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TargetNavigator::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = TargetNavigator::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -16679,167 +13823,123 @@ @implementation CHIPTemperatureMeasurement - (void)readAttributeMeasuredValueWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TemperatureMeasurement::Attributes::MeasuredValue::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TemperatureMeasurement::Attributes::MeasuredValue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMeasuredValue(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMeasuredValueWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMeasuredValue(success); + using TypeInfo = TemperatureMeasurement::Attributes::MeasuredValue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeMinMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TemperatureMeasurement::Attributes::MinMeasuredValue::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TemperatureMeasurement::Attributes::MinMeasuredValue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeMinMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMinMeasuredValue(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMinMeasuredValueWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMinMeasuredValue(success); + using TypeInfo = TemperatureMeasurement::Attributes::MinMeasuredValue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeMaxMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TemperatureMeasurement::Attributes::MaxMeasuredValue::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TemperatureMeasurement::Attributes::MaxMeasuredValue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeMaxMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMaxMeasuredValue(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMaxMeasuredValueWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMaxMeasuredValue(success); + using TypeInfo = TemperatureMeasurement::Attributes::MaxMeasuredValue::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeToleranceWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TemperatureMeasurement::Attributes::Tolerance::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TemperatureMeasurement::Attributes::Tolerance::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeToleranceWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeTolerance(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeToleranceWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeTolerance(success); + using TypeInfo = TemperatureMeasurement::Attributes::Tolerance::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPTemperatureMeasurementAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TemperatureMeasurement::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -16850,40 +13950,30 @@ new CHIPTemperatureMeasurementAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TemperatureMeasurement::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TemperatureMeasurement::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = TemperatureMeasurement::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -16911,11 +14001,7 @@ - (void)simpleStructEchoRequestWithParams:(CHIPTestClusterClusterSimpleStructEch request.arg1.h = params.arg1.h.doubleValue; new CHIPTestClusterClusterSimpleStructResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -16929,7 +14015,7 @@ - (void)testWithCompletionHandler:(StatusCompletion)completionHandler new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -16949,11 +14035,7 @@ - (void)testAddArgumentsWithParams:(CHIPTestClusterClusterTestAddArgumentsParams request.arg2 = params.arg2.unsignedCharValue; new CHIPTestClusterClusterTestAddArgumentsResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -16970,11 +14052,7 @@ - (void)testEnumsRequestWithParams:(CHIPTestClusterClusterTestEnumsRequestParams request.arg2 = static_cast>(params.arg2.unsignedCharValue); new CHIPTestClusterClusterTestEnumsResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -17011,11 +14089,7 @@ - (void)testListInt8UArgumentRequestWithParams:(CHIPTestClusterClusterTestListIn } new CHIPTestClusterClusterBooleanResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -17052,11 +14126,7 @@ - (void)testListInt8UReverseRequestWithParams:(CHIPTestClusterClusterTestListInt } new CHIPTestClusterClusterTestListInt8UReverseResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -17202,11 +14272,7 @@ - (void)testListNestedStructListArgumentRequestWithParams: } new CHIPTestClusterClusterBooleanResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -17252,11 +14318,7 @@ - (void)testListStructArgumentRequestWithParams:(CHIPTestClusterClusterTestListS } new CHIPTestClusterClusterBooleanResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -17281,11 +14343,7 @@ - (void)testNestedStructArgumentRequestWithParams:(CHIPTestClusterClusterTestNes request.arg1.c.h = params.arg1.c.h.doubleValue; new CHIPTestClusterClusterBooleanResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -17407,11 +14465,7 @@ - (void)testNestedStructListArgumentRequestWithParams:(CHIPTestClusterClusterTes } new CHIPTestClusterClusterBooleanResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -17425,7 +14479,7 @@ - (void)testNotHandledWithCompletionHandler:(StatusCompletion)completionHandler new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -17454,11 +14508,7 @@ - (void)testNullableOptionalRequestWithParams:(CHIPTestClusterClusterTestNullabl } new CHIPTestClusterClusterTestNullableOptionalResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -17480,7 +14530,7 @@ - (void)testSimpleOptionalArgumentRequestWithParams: new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -17497,11 +14547,7 @@ - (void)testSpecificWithCompletionHandler:(void (^)(CHIPTestClusterClusterTestSp TestCluster::Commands::TestSpecific::Type request; new CHIPTestClusterClusterTestSpecificResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -17524,11 +14570,7 @@ - (void)testStructArgumentRequestWithParams:(CHIPTestClusterClusterTestStructArg request.arg1.h = params.arg1.h.doubleValue; new CHIPTestClusterClusterBooleanResponseCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); @@ -17542,7 +14584,7 @@ - (void)testUnknownCommandWithCompletionHandler:(StatusCompletion)completionHand new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -17559,7 +14601,7 @@ - (void)timedInvokeRequestWithCompletionHandler:(StatusCompletion)completionHand new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -17571,24 +14613,19 @@ new CHIPCommandSuccessCallbackBridge( - (void)readAttributeBooleanWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPBooleanAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::Boolean::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::Boolean::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeBooleanWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -17604,46 +14641,36 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeBooleanWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeBoolean(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeBooleanWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPBooleanAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPBooleanAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeBoolean(success); + using TypeInfo = TestCluster::Attributes::Boolean::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeBitmap8WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::Bitmap8::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::Bitmap8::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeBitmap8WithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -17659,47 +14686,37 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeBitmap8WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeBitmap8(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeBitmap8WithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeBitmap8(success); + using TypeInfo = TestCluster::Attributes::Bitmap8::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeBitmap16WithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::Bitmap16::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::Bitmap16::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeBitmap16WithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -17715,47 +14732,37 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeBitmap16WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeBitmap16(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeBitmap16WithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeBitmap16(success); + using TypeInfo = TestCluster::Attributes::Bitmap16::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeBitmap32WithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::Bitmap32::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::Bitmap32::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeBitmap32WithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -17771,47 +14778,37 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeBitmap32WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeBitmap32(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeBitmap32WithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeBitmap32(success); + using TypeInfo = TestCluster::Attributes::Bitmap32::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeBitmap64WithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::Bitmap64::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::Bitmap64::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeBitmap64WithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -17827,46 +14824,36 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeBitmap64WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeBitmap64(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeBitmap64WithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeBitmap64(success); + using TypeInfo = TestCluster::Attributes::Bitmap64::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeInt8uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::Int8u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)writeAttributeInt8uWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +{ + new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::Int8u::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); -} - -- (void)writeAttributeInt8uWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler -{ - new CHIPDefaultSuccessCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -17882,46 +14869,36 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeInt8uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeInt8u(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeInt8uWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeInt8u(success); + using TypeInfo = TestCluster::Attributes::Int8u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeInt16uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::Int16u::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::Int16u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeInt16uWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -17937,46 +14914,36 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeInt16uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeInt16u(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeInt16uWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeInt16u(success); + using TypeInfo = TestCluster::Attributes::Int16u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeInt24uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::Int24u::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::Int24u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeInt24uWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -17992,46 +14959,36 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeInt24uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeInt24u(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeInt24uWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeInt24u(success); + using TypeInfo = TestCluster::Attributes::Int24u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeInt32uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::Int32u::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::Int32u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeInt32uWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -18047,46 +15004,36 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeInt32uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeInt32u(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeInt32uWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeInt32u(success); + using TypeInfo = TestCluster::Attributes::Int32u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeInt40uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::Int40u::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::Int40u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeInt40uWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -18102,46 +15049,36 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeInt40uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeInt40u(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeInt40uWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeInt40u(success); + using TypeInfo = TestCluster::Attributes::Int40u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeInt48uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::Int48u::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::Int48u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeInt48uWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -18157,46 +15094,36 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeInt48uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeInt48u(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeInt48uWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeInt48u(success); + using TypeInfo = TestCluster::Attributes::Int48u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeInt56uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::Int56u::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::Int56u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeInt56uWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -18212,46 +15139,36 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeInt56uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeInt56u(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeInt56uWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeInt56u(success); + using TypeInfo = TestCluster::Attributes::Int56u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeInt64uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::Int64u::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::Int64u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeInt64uWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -18267,46 +15184,36 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeInt64uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeInt64u(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeInt64uWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeInt64u(success); + using TypeInfo = TestCluster::Attributes::Int64u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeInt8sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::Int8s::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::Int8s::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeInt8sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -18322,46 +15229,36 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeInt8sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeInt8s(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeInt8sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeInt8s(success); + using TypeInfo = TestCluster::Attributes::Int8s::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeInt16sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::Int16s::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::Int16s::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeInt16sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -18377,46 +15274,36 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeInt16sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeInt16s(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeInt16sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeInt16s(success); + using TypeInfo = TestCluster::Attributes::Int16s::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeInt24sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::Int24s::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::Int24s::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeInt24sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -18432,46 +15319,36 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeInt24sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeInt24s(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeInt24sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeInt24s(success); + using TypeInfo = TestCluster::Attributes::Int24s::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeInt32sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::Int32s::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::Int32s::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeInt32sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -18487,46 +15364,36 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeInt32sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeInt32s(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeInt32sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeInt32s(success); + using TypeInfo = TestCluster::Attributes::Int32s::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeInt40sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::Int40s::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt64sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::Int40s::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeInt40sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -18542,46 +15409,36 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeInt40sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt64sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeInt40s(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeInt40sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeInt40s(success); + using TypeInfo = TestCluster::Attributes::Int40s::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeInt48sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::Int48s::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt64sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::Int48s::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeInt48sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -18597,46 +15454,36 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeInt48sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt64sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeInt48s(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeInt48sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeInt48s(success); + using TypeInfo = TestCluster::Attributes::Int48s::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeInt56sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::Int56s::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt64sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::Int56s::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeInt56sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -18652,46 +15499,36 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeInt56sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt64sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeInt56s(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeInt56sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeInt56s(success); + using TypeInfo = TestCluster::Attributes::Int56s::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeInt64sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::Int64s::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt64sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::Int64s::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeInt64sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -18707,46 +15544,36 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeInt64sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt64sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeInt64s(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeInt64sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeInt64s(success); + using TypeInfo = TestCluster::Attributes::Int64s::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeEnum8WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::Enum8::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::Enum8::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeEnum8WithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -18762,46 +15589,36 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeEnum8WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeEnum8(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeEnum8WithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeEnum8(success); + using TypeInfo = TestCluster::Attributes::Enum8::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeEnum16WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::Enum16::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::Enum16::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeEnum16WithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -18817,47 +15634,37 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeEnum16WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeEnum16(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeEnum16WithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeEnum16(success); + using TypeInfo = TestCluster::Attributes::Enum16::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeFloatSingleWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPFloatAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::FloatSingle::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPFloatAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::FloatSingle::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeFloatSingleWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -18873,48 +15680,37 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeFloatSingleWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPFloatAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeFloatSingle(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeFloatSingleWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPFloatAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPFloatAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeFloatSingle(success); + using TypeInfo = TestCluster::Attributes::FloatSingle::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPFloatAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeFloatDoubleWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPDoubleAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::FloatDouble::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPDoubleAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::FloatDouble::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeFloatDoubleWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -18930,36 +15726,26 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeFloatDoubleWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPDoubleAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeFloatDouble(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeFloatDoubleWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPDoubleAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPDoubleAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeFloatDouble(success); + using TypeInfo = TestCluster::Attributes::FloatDouble::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPDoubleAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeOctetStringWithCompletionHandler:(void (^)( NSData * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPOctetStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::OctetString::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -18971,7 +15757,7 @@ - (void)writeAttributeOctetStringWithValue:(NSData * _Nonnull)value completionHa { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -18987,35 +15773,26 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeOctetStringWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPOctetStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeOctetString(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeOctetStringWithResponseHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPOctetStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPOctetStringAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeOctetString(success); + using TypeInfo = TestCluster::Attributes::OctetString::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPOctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeListInt8uWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPTestClusterListInt8uListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::ListInt8u::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -19027,7 +15804,7 @@ - (void)writeAttributeListInt8uWithValue:(NSArray * _Nonnull)value completionHan { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -19062,15 +15839,29 @@ new CHIPDefaultSuccessCallbackBridge( }); } +- (void)subscribeAttributeListInt8uWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + new CHIPTestClusterListInt8uListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::ListInt8u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPTestClusterListInt8uListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); +} + - (void)readAttributeListOctetStringWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPTestClusterListOctetStringListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::ListOctetString::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -19082,7 +15873,7 @@ - (void)writeAttributeListOctetStringWithValue:(NSArray * _Nonnull)value complet { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -19117,15 +15908,30 @@ new CHIPDefaultSuccessCallbackBridge( }); } +- (void)subscribeAttributeListOctetStringWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + new CHIPTestClusterListOctetStringListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::ListOctetString::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPTestClusterListOctetStringListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); +} + - (void)readAttributeListStructOctetStringWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPTestClusterListStructOctetStringListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::ListStructOctetString::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -19137,7 +15943,7 @@ - (void)writeAttributeListStructOctetStringWithValue:(NSArray * _Nonnull)value c { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -19173,15 +15979,31 @@ new CHIPDefaultSuccessCallbackBridge( }); } +- (void)subscribeAttributeListStructOctetStringWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + new CHIPTestClusterListStructOctetStringListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::ListStructOctetString::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPTestClusterListStructOctetStringListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); +} + - (void)readAttributeLongOctetStringWithCompletionHandler:(void (^)( NSData * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPOctetStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::LongOctetString::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -19193,7 +16015,7 @@ - (void)writeAttributeLongOctetStringWithValue:(NSData * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -19209,48 +16031,38 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeLongOctetStringWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPOctetStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeLongOctetString(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeLongOctetStringWithResponseHandler:(void (^)( - NSData * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPOctetStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPOctetStringAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeLongOctetString(success); + using TypeInfo = TestCluster::Attributes::LongOctetString::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPOctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeCharStringWithCompletionHandler:(void (^)( NSString * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::CharString::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::CharString::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeCharStringWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -19266,48 +16078,37 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeCharStringWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCharString(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeCharStringWithResponseHandler:(void (^)( - NSString * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPCharStringAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCharString(success); + using TypeInfo = TestCluster::Attributes::CharString::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeLongCharStringWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::LongCharString::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::LongCharString::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeLongCharStringWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -19323,47 +16124,37 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeLongCharStringWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeLongCharString(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeLongCharStringWithResponseHandler:(void (^)( - NSString * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPCharStringAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeLongCharString(success); + using TypeInfo = TestCluster::Attributes::LongCharString::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeEpochUsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::EpochUs::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::EpochUs::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeEpochUsWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -19379,46 +16170,36 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeEpochUsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeEpochUs(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeEpochUsWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeEpochUs(success); + using TypeInfo = TestCluster::Attributes::EpochUs::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeEpochSWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::EpochS::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::EpochS::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeEpochSWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -19434,47 +16215,37 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeEpochSWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeEpochS(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeEpochSWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeEpochS(success); + using TypeInfo = TestCluster::Attributes::EpochS::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeVendorIdWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPVendorIdAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::VendorId::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPVendorIdAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::VendorId::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeVendorIdWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -19490,35 +16261,26 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeVendorIdWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeVendorId(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeVendorIdWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPVendorIdAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeVendorId(success); + using TypeInfo = TestCluster::Attributes::VendorId::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPVendorIdAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeListNullablesAndOptionalsStructWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::ListNullablesAndOptionalsStruct::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -19526,15 +16288,31 @@ new CHIPTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge( }); } +- (void)subscribeAttributeListNullablesAndOptionalsStructWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, + NSError * _Nullable error))reportHandler +{ + new CHIPTestClusterListNullablesAndOptionalsStructListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::ListNullablesAndOptionalsStruct::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPTestClusterListNullablesAndOptionalsStructListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); +} + - (void)readAttributeEnumAttrWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPTestClusterClusterSimpleEnumAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::EnumAttr::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -19546,7 +16324,7 @@ - (void)writeAttributeEnumAttrWithValue:(NSNumber * _Nonnull)value completionHan { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -19562,47 +16340,38 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeEnumAttrWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeEnumAttr(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeEnumAttrWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeEnumAttr(success); + using TypeInfo = TestCluster::Attributes::EnumAttr::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeRangeRestrictedInt8uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::RangeRestrictedInt8u::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::RangeRestrictedInt8u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeRangeRestrictedInt8uWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -19618,48 +16387,39 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeRangeRestrictedInt8uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeRangeRestrictedInt8u(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeRangeRestrictedInt8uWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeRangeRestrictedInt8u(success); + using TypeInfo = TestCluster::Attributes::RangeRestrictedInt8u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeRangeRestrictedInt8sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::RangeRestrictedInt8s::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::RangeRestrictedInt8s::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeRangeRestrictedInt8sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -19675,41 +16435,32 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeRangeRestrictedInt8sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeRangeRestrictedInt8s(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeRangeRestrictedInt8sWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeRangeRestrictedInt8s(success); + using TypeInfo = TestCluster::Attributes::RangeRestrictedInt8s::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeRangeRestrictedInt16uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::RangeRestrictedInt16u::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::RangeRestrictedInt16u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeRangeRestrictedInt16uWithValue:(NSNumber * _Nonnull)value @@ -19717,7 +16468,7 @@ - (void)writeAttributeRangeRestrictedInt16uWithValue:(NSNumber * _Nonnull)value { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -19733,41 +16484,32 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeRangeRestrictedInt16uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeRangeRestrictedInt16u(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeRangeRestrictedInt16uWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeRangeRestrictedInt16u(success); + using TypeInfo = TestCluster::Attributes::RangeRestrictedInt16u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeRangeRestrictedInt16sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::RangeRestrictedInt16s::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::RangeRestrictedInt16s::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeRangeRestrictedInt16sWithValue:(NSNumber * _Nonnull)value @@ -19775,7 +16517,7 @@ - (void)writeAttributeRangeRestrictedInt16sWithValue:(NSNumber * _Nonnull)value { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -19791,36 +16533,28 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeRangeRestrictedInt16sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeRangeRestrictedInt16s(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeRangeRestrictedInt16sWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeRangeRestrictedInt16s(success); + using TypeInfo = TestCluster::Attributes::RangeRestrictedInt16s::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeListLongOctetStringWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPTestClusterListLongOctetStringListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::ListLongOctetString::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -19831,24 +16565,19 @@ new CHIPTestClusterListLongOctetStringListAttributeCallbackBridge( - (void)readAttributeTimedWriteBooleanWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPBooleanAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::TimedWriteBoolean::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::TimedWriteBoolean::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeTimedWriteBooleanWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -19866,24 +16595,19 @@ new CHIPDefaultSuccessCallbackBridge( - (void)readAttributeUnsupportedWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPBooleanAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::Unsupported::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::Unsupported::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeUnsupportedWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -19899,36 +16623,26 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeUnsupportedWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeUnsupported(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeUnsupportedWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPBooleanAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPBooleanAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeUnsupported(success); + using TypeInfo = TestCluster::Attributes::Unsupported::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNullableBooleanWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableBooleanAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::NullableBoolean::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -19940,7 +16654,7 @@ - (void)writeAttributeNullableBooleanWithValue:(NSNumber * _Nullable)value compl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -19961,37 +16675,27 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeNullableBooleanWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableBooleanAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableBoolean(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNullableBooleanWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableBooleanAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableBooleanAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableBoolean(success); + using TypeInfo = TestCluster::Attributes::NullableBoolean::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNullableBitmap8WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::NullableBitmap8::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -20003,7 +16707,7 @@ - (void)writeAttributeNullableBitmap8WithValue:(NSNumber * _Nullable)value compl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -20024,37 +16728,27 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeNullableBitmap8WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt8uAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableBitmap8(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNullableBitmap8WithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableBitmap8(success); + using TypeInfo = TestCluster::Attributes::NullableBitmap8::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNullableBitmap16WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::NullableBitmap16::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -20066,7 +16760,7 @@ - (void)writeAttributeNullableBitmap16WithValue:(NSNumber * _Nullable)value comp { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -20087,37 +16781,27 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeNullableBitmap16WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt16uAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableBitmap16(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNullableBitmap16WithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableBitmap16(success); + using TypeInfo = TestCluster::Attributes::NullableBitmap16::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNullableBitmap32WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::NullableBitmap32::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -20129,7 +16813,7 @@ - (void)writeAttributeNullableBitmap32WithValue:(NSNumber * _Nullable)value comp { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -20150,37 +16834,27 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeNullableBitmap32WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt32uAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableBitmap32(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNullableBitmap32WithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableBitmap32(success); + using TypeInfo = TestCluster::Attributes::NullableBitmap32::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNullableBitmap64WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::NullableBitmap64::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -20192,7 +16866,7 @@ - (void)writeAttributeNullableBitmap64WithValue:(NSNumber * _Nullable)value comp { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -20213,37 +16887,27 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeNullableBitmap64WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt64uAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableBitmap64(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNullableBitmap64WithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableBitmap64(success); + using TypeInfo = TestCluster::Attributes::NullableBitmap64::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNullableInt8uWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::NullableInt8u::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -20255,7 +16919,7 @@ - (void)writeAttributeNullableInt8uWithValue:(NSNumber * _Nullable)value complet { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -20276,37 +16940,27 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeNullableInt8uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt8uAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableInt8u(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNullableInt8uWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableInt8u(success); + using TypeInfo = TestCluster::Attributes::NullableInt8u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNullableInt16uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::NullableInt16u::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -20318,7 +16972,7 @@ - (void)writeAttributeNullableInt16uWithValue:(NSNumber * _Nullable)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -20339,37 +16993,27 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeNullableInt16uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt16uAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableInt16u(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNullableInt16uWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableInt16u(success); + using TypeInfo = TestCluster::Attributes::NullableInt16u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNullableInt24uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::NullableInt24u::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -20381,7 +17025,7 @@ - (void)writeAttributeNullableInt24uWithValue:(NSNumber * _Nullable)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -20402,37 +17046,27 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeNullableInt24uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt32uAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableInt24u(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNullableInt24uWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableInt24u(success); + using TypeInfo = TestCluster::Attributes::NullableInt24u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNullableInt32uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::NullableInt32u::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -20444,7 +17078,7 @@ - (void)writeAttributeNullableInt32uWithValue:(NSNumber * _Nullable)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -20465,37 +17099,27 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeNullableInt32uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt32uAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableInt32u(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNullableInt32uWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableInt32u(success); + using TypeInfo = TestCluster::Attributes::NullableInt32u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNullableInt40uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::NullableInt40u::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -20507,7 +17131,7 @@ - (void)writeAttributeNullableInt40uWithValue:(NSNumber * _Nullable)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -20528,37 +17152,27 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeNullableInt40uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt64uAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableInt40u(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNullableInt40uWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableInt40u(success); + using TypeInfo = TestCluster::Attributes::NullableInt40u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNullableInt48uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::NullableInt48u::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -20570,7 +17184,7 @@ - (void)writeAttributeNullableInt48uWithValue:(NSNumber * _Nullable)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -20591,37 +17205,27 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeNullableInt48uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt64uAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableInt48u(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNullableInt48uWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableInt48u(success); + using TypeInfo = TestCluster::Attributes::NullableInt48u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNullableInt56uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::NullableInt56u::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -20633,7 +17237,7 @@ - (void)writeAttributeNullableInt56uWithValue:(NSNumber * _Nullable)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -20654,37 +17258,27 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeNullableInt56uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt64uAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableInt56u(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNullableInt56uWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableInt56u(success); + using TypeInfo = TestCluster::Attributes::NullableInt56u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNullableInt64uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::NullableInt64u::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -20696,7 +17290,7 @@ - (void)writeAttributeNullableInt64uWithValue:(NSNumber * _Nullable)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -20717,37 +17311,27 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeNullableInt64uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt64uAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableInt64u(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNullableInt64uWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableInt64u(success); + using TypeInfo = TestCluster::Attributes::NullableInt64u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNullableInt8sWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt8sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::NullableInt8s::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -20759,7 +17343,7 @@ - (void)writeAttributeNullableInt8sWithValue:(NSNumber * _Nullable)value complet { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -20780,37 +17364,27 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeNullableInt8sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt8sAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableInt8s(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNullableInt8sWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt8sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt8sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableInt8s(success); + using TypeInfo = TestCluster::Attributes::NullableInt8s::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNullableInt16sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::NullableInt16s::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -20822,7 +17396,7 @@ - (void)writeAttributeNullableInt16sWithValue:(NSNumber * _Nullable)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -20843,37 +17417,27 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeNullableInt16sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt16sAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableInt16s(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNullableInt16sWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableInt16s(success); + using TypeInfo = TestCluster::Attributes::NullableInt16s::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNullableInt24sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt32sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::NullableInt24s::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -20885,7 +17449,7 @@ - (void)writeAttributeNullableInt24sWithValue:(NSNumber * _Nullable)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -20906,37 +17470,27 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeNullableInt24sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt32sAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableInt24s(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNullableInt24sWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt32sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt32sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableInt24s(success); + using TypeInfo = TestCluster::Attributes::NullableInt24s::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNullableInt32sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt32sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::NullableInt32s::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -20948,7 +17502,7 @@ - (void)writeAttributeNullableInt32sWithValue:(NSNumber * _Nullable)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -20969,37 +17523,27 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeNullableInt32sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt32sAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableInt32s(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNullableInt32sWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt32sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt32sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableInt32s(success); + using TypeInfo = TestCluster::Attributes::NullableInt32s::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNullableInt40sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt64sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::NullableInt40s::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -21011,7 +17555,7 @@ - (void)writeAttributeNullableInt40sWithValue:(NSNumber * _Nullable)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -21032,37 +17576,27 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeNullableInt40sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt64sAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableInt40s(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNullableInt40sWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt64sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt64sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableInt40s(success); + using TypeInfo = TestCluster::Attributes::NullableInt40s::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNullableInt48sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt64sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::NullableInt48s::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -21074,7 +17608,7 @@ - (void)writeAttributeNullableInt48sWithValue:(NSNumber * _Nullable)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -21095,37 +17629,27 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeNullableInt48sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt64sAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableInt48s(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNullableInt48sWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt64sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt64sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableInt48s(success); + using TypeInfo = TestCluster::Attributes::NullableInt48s::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNullableInt56sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt64sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::NullableInt56s::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -21137,7 +17661,7 @@ - (void)writeAttributeNullableInt56sWithValue:(NSNumber * _Nullable)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -21158,37 +17682,27 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeNullableInt56sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt64sAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableInt56s(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNullableInt56sWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt64sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt64sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableInt56s(success); + using TypeInfo = TestCluster::Attributes::NullableInt56s::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNullableInt64sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt64sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::NullableInt64s::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -21200,7 +17714,7 @@ - (void)writeAttributeNullableInt64sWithValue:(NSNumber * _Nullable)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -21221,37 +17735,27 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeNullableInt64sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt64sAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableInt64s(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNullableInt64sWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt64sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt64sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableInt64s(success); + using TypeInfo = TestCluster::Attributes::NullableInt64s::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNullableEnum8WithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::NullableEnum8::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -21263,7 +17767,7 @@ - (void)writeAttributeNullableEnum8WithValue:(NSNumber * _Nullable)value complet { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -21284,37 +17788,27 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeNullableEnum8WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt8uAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableEnum8(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNullableEnum8WithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableEnum8(success); + using TypeInfo = TestCluster::Attributes::NullableEnum8::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNullableEnum16WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::NullableEnum16::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -21326,7 +17820,7 @@ - (void)writeAttributeNullableEnum16WithValue:(NSNumber * _Nullable)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -21347,37 +17841,27 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeNullableEnum16WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt16uAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableEnum16(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNullableEnum16WithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableEnum16(success); + using TypeInfo = TestCluster::Attributes::NullableEnum16::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNullableFloatSingleWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableFloatAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::NullableFloatSingle::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -21389,7 +17873,7 @@ - (void)writeAttributeNullableFloatSingleWithValue:(NSNumber * _Nullable)value c { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -21410,37 +17894,28 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeNullableFloatSingleWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableFloatAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableFloatSingle(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNullableFloatSingleWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableFloatAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableFloatAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableFloatSingle(success); + using TypeInfo = TestCluster::Attributes::NullableFloatSingle::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableFloatAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNullableFloatDoubleWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableDoubleAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::NullableFloatDouble::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -21452,7 +17927,7 @@ - (void)writeAttributeNullableFloatDoubleWithValue:(NSNumber * _Nullable)value c { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -21473,37 +17948,28 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeNullableFloatDoubleWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableDoubleAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableFloatDouble(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNullableFloatDoubleWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableDoubleAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableDoubleAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableFloatDouble(success); + using TypeInfo = TestCluster::Attributes::NullableFloatDouble::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableDoubleAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNullableOctetStringWithCompletionHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableOctetStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::NullableOctetString::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -21515,7 +17981,7 @@ - (void)writeAttributeNullableOctetStringWithValue:(NSData * _Nullable)value com { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -21536,37 +18002,28 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeNullableOctetStringWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableOctetStringAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableOctetString(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNullableOctetStringWithResponseHandler:(void (^)(NSData * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableOctetStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableOctetStringAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableOctetString(success); + using TypeInfo = TestCluster::Attributes::NullableOctetString::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableOctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNullableCharStringWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::NullableCharString::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -21578,7 +18035,7 @@ - (void)writeAttributeNullableCharStringWithValue:(NSString * _Nullable)value co { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -21599,37 +18056,27 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeNullableCharStringWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableCharStringAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableCharString(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNullableCharStringWithResponseHandler:(void (^)(NSString * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableCharStringAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableCharString(success); + using TypeInfo = TestCluster::Attributes::NullableCharString::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNullableEnumAttrWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableTestClusterClusterSimpleEnumAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::NullableEnumAttr::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -21641,7 +18088,7 @@ - (void)writeAttributeNullableEnumAttrWithValue:(NSNumber * _Nullable)value comp { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -21662,37 +18109,28 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeNullableEnumAttrWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPNullableInt8uAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableEnumAttr(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNullableEnumAttrWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler -{ - new CHIPNullableInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableEnumAttr(success); + using TypeInfo = TestCluster::Attributes::NullableEnumAttr::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPNullableTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNullableRangeRestrictedInt8uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt8u::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -21705,7 +18143,7 @@ - (void)writeAttributeNullableRangeRestrictedInt8uWithValue:(NSNumber * _Nullabl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -21726,37 +18164,28 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeNullableRangeRestrictedInt8uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt8uAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableRangeRestrictedInt8u(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNullableRangeRestrictedInt8uWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPNullableInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableRangeRestrictedInt8u(success); + using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt8u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNullableRangeRestrictedInt8sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt8sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt8s::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -21769,7 +18198,7 @@ - (void)writeAttributeNullableRangeRestrictedInt8sWithValue:(NSNumber * _Nullabl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -21790,37 +18219,28 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeNullableRangeRestrictedInt8sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt8sAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableRangeRestrictedInt8s(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNullableRangeRestrictedInt8sWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPNullableInt8sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt8sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableRangeRestrictedInt8s(success); + using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt8s::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNullableRangeRestrictedInt16uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt16u::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -21833,7 +18253,7 @@ - (void)writeAttributeNullableRangeRestrictedInt16uWithValue:(NSNumber * _Nullab { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -21854,37 +18274,28 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeNullableRangeRestrictedInt16uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt16uAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableRangeRestrictedInt16u(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNullableRangeRestrictedInt16uWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPNullableInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableRangeRestrictedInt16u(success); + using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt16u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNullableRangeRestrictedInt16sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPNullableInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt16s::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -21897,7 +18308,7 @@ - (void)writeAttributeNullableRangeRestrictedInt16sWithValue:(NSNumber * _Nullab { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -21918,37 +18329,28 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeNullableRangeRestrictedInt16sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPNullableInt16sAttributeCallbackBridge( - self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableRangeRestrictedInt16s(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNullableRangeRestrictedInt16sWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPNullableInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPNullableInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableRangeRestrictedInt16s(success); + using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt16s::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPTestClusterAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = TestCluster::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -21959,40 +18361,30 @@ new CHIPTestClusterAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = TestCluster::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -22011,7 +18403,7 @@ - (void)clearWeeklyScheduleWithCompletionHandler:(StatusCompletion)completionHan new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -22028,7 +18420,7 @@ - (void)getRelayStatusLogWithCompletionHandler:(StatusCompletion)completionHandl new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -22050,7 +18442,7 @@ - (void)getWeeklyScheduleWithParams:(CHIPThermostatClusterGetWeeklyScheduleParam new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -22095,7 +18487,7 @@ - (void)setWeeklyScheduleWithParams:(CHIPThermostatClusterSetWeeklyScheduleParam new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -22115,7 +18507,7 @@ - (void)setpointRaiseLowerWithParams:(CHIPThermostatClusterSetpointRaiseLowerPar new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -22128,212 +18520,161 @@ new CHIPCommandSuccessCallbackBridge( - (void)readAttributeLocalTemperatureWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Thermostat::Attributes::LocalTemperature::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Thermostat::Attributes::LocalTemperature::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeLocalTemperatureWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeLocalTemperature(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeLocalTemperatureWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler -{ - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeLocalTemperature(success); + using TypeInfo = Thermostat::Attributes::LocalTemperature::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAbsMinHeatSetpointLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Thermostat::Attributes::AbsMinHeatSetpointLimit::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Thermostat::Attributes::AbsMinHeatSetpointLimit::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeAbsMinHeatSetpointLimitWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeAbsMinHeatSetpointLimit(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeAbsMinHeatSetpointLimitWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeAbsMinHeatSetpointLimit(success); + using TypeInfo = Thermostat::Attributes::AbsMinHeatSetpointLimit::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAbsMaxHeatSetpointLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Thermostat::Attributes::AbsMaxHeatSetpointLimit::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Thermostat::Attributes::AbsMaxHeatSetpointLimit::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeAbsMaxHeatSetpointLimitWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeAbsMaxHeatSetpointLimit(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeAbsMaxHeatSetpointLimitWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeAbsMaxHeatSetpointLimit(success); + using TypeInfo = Thermostat::Attributes::AbsMaxHeatSetpointLimit::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAbsMinCoolSetpointLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Thermostat::Attributes::AbsMinCoolSetpointLimit::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Thermostat::Attributes::AbsMinCoolSetpointLimit::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeAbsMinCoolSetpointLimitWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeAbsMinCoolSetpointLimit(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeAbsMinCoolSetpointLimitWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeAbsMinCoolSetpointLimit(success); + using TypeInfo = Thermostat::Attributes::AbsMinCoolSetpointLimit::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAbsMaxCoolSetpointLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Thermostat::Attributes::AbsMaxCoolSetpointLimit::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Thermostat::Attributes::AbsMaxCoolSetpointLimit::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeAbsMaxCoolSetpointLimitWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeAbsMaxCoolSetpointLimit(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeAbsMaxCoolSetpointLimitWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler -{ - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeAbsMaxCoolSetpointLimit(success); + using TypeInfo = Thermostat::Attributes::AbsMaxCoolSetpointLimit::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeOccupiedCoolingSetpointWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Thermostat::Attributes::OccupiedCoolingSetpoint::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Thermostat::Attributes::OccupiedCoolingSetpoint::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeOccupiedCoolingSetpointWithValue:(NSNumber * _Nonnull)value @@ -22341,7 +18682,7 @@ - (void)writeAttributeOccupiedCoolingSetpointWithValue:(NSNumber * _Nonnull)valu { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -22357,41 +18698,32 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeOccupiedCoolingSetpointWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeOccupiedCoolingSetpoint(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeOccupiedCoolingSetpointWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeOccupiedCoolingSetpoint(success); + using TypeInfo = Thermostat::Attributes::OccupiedCoolingSetpoint::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeOccupiedHeatingSetpointWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Thermostat::Attributes::OccupiedHeatingSetpoint::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Thermostat::Attributes::OccupiedHeatingSetpoint::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeOccupiedHeatingSetpointWithValue:(NSNumber * _Nonnull)value @@ -22399,7 +18731,7 @@ - (void)writeAttributeOccupiedHeatingSetpointWithValue:(NSNumber * _Nonnull)valu { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -22415,48 +18747,39 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeOccupiedHeatingSetpointWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeOccupiedHeatingSetpoint(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeOccupiedHeatingSetpointWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeOccupiedHeatingSetpoint(success); + using TypeInfo = Thermostat::Attributes::OccupiedHeatingSetpoint::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeMinHeatSetpointLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Thermostat::Attributes::MinHeatSetpointLimit::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Thermostat::Attributes::MinHeatSetpointLimit::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeMinHeatSetpointLimitWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -22472,48 +18795,39 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeMinHeatSetpointLimitWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMinHeatSetpointLimit(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMinHeatSetpointLimitWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMinHeatSetpointLimit(success); + using TypeInfo = Thermostat::Attributes::MinHeatSetpointLimit::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeMaxHeatSetpointLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Thermostat::Attributes::MaxHeatSetpointLimit::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Thermostat::Attributes::MaxHeatSetpointLimit::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeMaxHeatSetpointLimitWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -22529,49 +18843,40 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeMaxHeatSetpointLimitWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMaxHeatSetpointLimit(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMaxHeatSetpointLimitWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler -{ - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMaxHeatSetpointLimit(success); + using TypeInfo = Thermostat::Attributes::MaxHeatSetpointLimit::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeMinCoolSetpointLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Thermostat::Attributes::MinCoolSetpointLimit::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)writeAttributeMinCoolSetpointLimitWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +{ + new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Thermostat::Attributes::MinCoolSetpointLimit::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); -} - -- (void)writeAttributeMinCoolSetpointLimitWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler -{ - new CHIPDefaultSuccessCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { - completionHandler(error); + ^(id _Nullable ignored, NSError * _Nullable error) { + completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; @@ -22586,48 +18891,39 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeMinCoolSetpointLimitWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMinCoolSetpointLimit(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMinCoolSetpointLimitWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMinCoolSetpointLimit(success); + using TypeInfo = Thermostat::Attributes::MinCoolSetpointLimit::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeMaxCoolSetpointLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Thermostat::Attributes::MaxCoolSetpointLimit::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Thermostat::Attributes::MaxCoolSetpointLimit::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeMaxCoolSetpointLimitWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -22643,48 +18939,39 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeMaxCoolSetpointLimitWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMaxCoolSetpointLimit(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMaxCoolSetpointLimitWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler -{ - new CHIPInt16sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMaxCoolSetpointLimit(success); + using TypeInfo = Thermostat::Attributes::MaxCoolSetpointLimit::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeMinSetpointDeadBandWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Thermostat::Attributes::MinSetpointDeadBand::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Thermostat::Attributes::MinSetpointDeadBand::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeMinSetpointDeadBandWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -22700,41 +18987,32 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeMinSetpointDeadBandWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMinSetpointDeadBand(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMinSetpointDeadBandWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMinSetpointDeadBand(success); + using TypeInfo = Thermostat::Attributes::MinSetpointDeadBand::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeControlSequenceOfOperationWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Thermostat::Attributes::ControlSequenceOfOperation::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Thermostat::Attributes::ControlSequenceOfOperation::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeControlSequenceOfOperationWithValue:(NSNumber * _Nonnull)value @@ -22742,7 +19020,7 @@ - (void)writeAttributeControlSequenceOfOperationWithValue:(NSNumber * _Nonnull)v { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -22758,48 +19036,39 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeControlSequenceOfOperationWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeControlSequenceOfOperation(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeControlSequenceOfOperationWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeControlSequenceOfOperation(success); + using TypeInfo = Thermostat::Attributes::ControlSequenceOfOperation::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeSystemModeWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Thermostat::Attributes::SystemMode::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Thermostat::Attributes::SystemMode::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeSystemModeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -22815,153 +19084,114 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeSystemModeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeSystemMode(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeSystemModeWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeSystemMode(success); + using TypeInfo = Thermostat::Attributes::SystemMode::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeStartOfWeekWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Thermostat::Attributes::StartOfWeek::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Thermostat::Attributes::StartOfWeek::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeStartOfWeekWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeStartOfWeek(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeStartOfWeekWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeStartOfWeek(success); + using TypeInfo = Thermostat::Attributes::StartOfWeek::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNumberOfWeeklyTransitionsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Thermostat::Attributes::NumberOfWeeklyTransitions::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Thermostat::Attributes::NumberOfWeeklyTransitions::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeNumberOfWeeklyTransitionsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNumberOfWeeklyTransitions(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNumberOfWeeklyTransitionsWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNumberOfWeeklyTransitions(success); + using TypeInfo = Thermostat::Attributes::NumberOfWeeklyTransitions::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNumberOfDailyTransitionsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Thermostat::Attributes::NumberOfDailyTransitions::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Thermostat::Attributes::NumberOfDailyTransitions::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeNumberOfDailyTransitionsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNumberOfDailyTransitions(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNumberOfDailyTransitionsWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNumberOfDailyTransitions(success); + using TypeInfo = Thermostat::Attributes::NumberOfDailyTransitions::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPThermostatAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = Thermostat::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -22972,79 +19202,58 @@ new CHIPThermostatAttributeListListAttributeCallbackBridge( - (void)readAttributeFeatureMapWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Thermostat::Attributes::FeatureMap::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Thermostat::Attributes::FeatureMap::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeFeatureMapWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeFeatureMap(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeFeatureMapWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeFeatureMap(success); + using TypeInfo = Thermostat::Attributes::FeatureMap::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = Thermostat::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = Thermostat::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = Thermostat::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -23059,17 +19268,12 @@ @implementation CHIPThermostatUserInterfaceConfiguration - (void)readAttributeTemperatureDisplayModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::TemperatureDisplayMode::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::TemperatureDisplayMode::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeTemperatureDisplayModeWithValue:(NSNumber * _Nonnull)value @@ -23077,7 +19281,7 @@ - (void)writeAttributeTemperatureDisplayModeWithValue:(NSNumber * _Nonnull)value { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -23093,48 +19297,39 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeTemperatureDisplayModeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeTemperatureDisplayMode(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeTemperatureDisplayModeWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeTemperatureDisplayMode(success); + using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::TemperatureDisplayMode::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeKeypadLockoutWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::KeypadLockout::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::KeypadLockout::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeKeypadLockoutWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -23150,41 +19345,31 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeKeypadLockoutWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeKeypadLockout(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeKeypadLockoutWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeKeypadLockout(success); + using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::KeypadLockout::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeScheduleProgrammingVisibilityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::ScheduleProgrammingVisibility::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::ScheduleProgrammingVisibility::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeScheduleProgrammingVisibilityWithValue:(NSNumber * _Nonnull)value @@ -23192,7 +19377,7 @@ - (void)writeAttributeScheduleProgrammingVisibilityWithValue:(NSNumber * _Nonnul { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -23208,36 +19393,28 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeScheduleProgrammingVisibilityWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeScheduleProgrammingVisibility(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeScheduleProgrammingVisibilityWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeScheduleProgrammingVisibility(success); + using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::ScheduleProgrammingVisibility::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); @@ -23249,40 +19426,30 @@ new CHIPThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackBr - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::ClusterRevision::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); -} - -- (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); - }, - true); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); } @end @@ -23301,7 +19468,7 @@ - (void)resetCountsWithCompletionHandler:(StatusCompletion)completionHandler new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -23313,89 +19480,64 @@ new CHIPCommandSuccessCallbackBridge( - (void)readAttributeChannelWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::Channel::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::Channel::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeChannelWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeChannel(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeChannelWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeChannel(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::Channel::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeRoutingRoleWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::RoutingRole::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RoutingRole::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeRoutingRoleWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeRoutingRole(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeRoutingRoleWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeRoutingRole(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RoutingRole::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNetworkNameWithCompletionHandler:(void (^)( NSData * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPOctetStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = ThreadNetworkDiagnostics::Attributes::NetworkName::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -23405,111 +19547,82 @@ new CHIPOctetStringAttributeCallbackBridge( - (void)subscribeAttributeNetworkNameWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPOctetStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNetworkName(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeNetworkNameWithResponseHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPOctetStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPOctetStringAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNetworkName(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::NetworkName::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPOctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributePanIdWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::PanId::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::PanId::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributePanIdWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePanId(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributePanIdWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePanId(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::PanId::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeExtendedPanIdWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::ExtendedPanId::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::ExtendedPanId::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeExtendedPanIdWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeExtendedPanId(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeExtendedPanIdWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeExtendedPanId(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::ExtendedPanId::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeMeshLocalPrefixWithCompletionHandler:(void (^)( NSData * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPOctetStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = ThreadNetworkDiagnostics::Attributes::MeshLocalPrefix::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -23519,75 +19632,55 @@ new CHIPOctetStringAttributeCallbackBridge( - (void)subscribeAttributeMeshLocalPrefixWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPOctetStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMeshLocalPrefix(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeMeshLocalPrefixWithResponseHandler:(void (^)( - NSData * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPOctetStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPOctetStringAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMeshLocalPrefix(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::MeshLocalPrefix::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPOctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeOverrunCountWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::OverrunCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::OverrunCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeOverrunCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeOverrunCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeOverrunCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeOverrunCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::OverrunCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeNeighborTableListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = ThreadNetworkDiagnostics::Attributes::NeighborTableList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -23595,15 +19688,30 @@ new CHIPThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackBridge( }); } +- (void)subscribeAttributeNeighborTableListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + new CHIPThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::NeighborTableList::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); +} + - (void)readAttributeRouteTableListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPThreadNetworkDiagnosticsRouteTableListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = ThreadNetworkDiagnostics::Attributes::RouteTableList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -23611,1962 +19719,1480 @@ new CHIPThreadNetworkDiagnosticsRouteTableListListAttributeCallbackBridge( }); } -- (void)readAttributePartitionIdWithCompletionHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))completionHandler +- (void)subscribeAttributeRouteTableListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, + new CHIPThreadNetworkDiagnosticsRouteTableListListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::PartitionId::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RouteTableList::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPThreadNetworkDiagnosticsRouteTableListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); } -- (void)subscribeAttributePartitionIdWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)readAttributePartitionIdWithCompletionHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePartitionId(success, failure, minInterval, maxInterval); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::PartitionId::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)reportAttributePartitionIdWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +- (void)subscribeAttributePartitionIdWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePartitionId(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::PartitionId::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeWeightingWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::Weighting::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::Weighting::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeWeightingWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeWeighting(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeWeightingWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeWeighting(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::Weighting::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeDataVersionWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::DataVersion::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::DataVersion::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeDataVersionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeDataVersion(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeDataVersionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeDataVersion(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::DataVersion::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeStableDataVersionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::StableDataVersion::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::StableDataVersion::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeStableDataVersionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeStableDataVersion(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeStableDataVersionWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeStableDataVersion(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::StableDataVersion::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeLeaderRouterIdWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::LeaderRouterId::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::LeaderRouterId::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeLeaderRouterIdWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeLeaderRouterId(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeLeaderRouterIdWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeLeaderRouterId(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::LeaderRouterId::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeDetachedRoleCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::DetachedRoleCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributeDetachedRoleCountWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = ThreadNetworkDiagnostics::Attributes::DetachedRoleCount::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); } -- (void)subscribeAttributeDetachedRoleCountWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)readAttributeChildRoleCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeDetachedRoleCount(success, failure, minInterval, maxInterval); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::ChildRoleCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)reportAttributeDetachedRoleCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler +- (void)subscribeAttributeChildRoleCountWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeDetachedRoleCount(success); - }, - true); -} - -- (void)readAttributeChildRoleCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))completionHandler -{ - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = ThreadNetworkDiagnostics::Attributes::ChildRoleCount::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); -} - -- (void)subscribeAttributeChildRoleCountWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeChildRoleCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeChildRoleCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeChildRoleCount(success); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeRouterRoleCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::RouterRoleCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RouterRoleCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeRouterRoleCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeRouterRoleCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeRouterRoleCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeRouterRoleCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RouterRoleCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeLeaderRoleCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::LeaderRoleCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::LeaderRoleCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeLeaderRoleCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeLeaderRoleCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeLeaderRoleCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeLeaderRoleCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::LeaderRoleCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttachAttemptCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::AttachAttemptCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::AttachAttemptCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeAttachAttemptCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeAttachAttemptCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeAttachAttemptCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeAttachAttemptCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::AttachAttemptCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributePartitionIdChangeCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::PartitionIdChangeCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::PartitionIdChangeCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributePartitionIdChangeCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePartitionIdChangeCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributePartitionIdChangeCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler -{ - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePartitionIdChangeCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::PartitionIdChangeCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeBetterPartitionAttachAttemptCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::BetterPartitionAttachAttemptCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::BetterPartitionAttachAttemptCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeBetterPartitionAttachAttemptCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeBetterPartitionAttachAttemptCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeBetterPartitionAttachAttemptCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeBetterPartitionAttachAttemptCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::BetterPartitionAttachAttemptCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeParentChangeCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::ParentChangeCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::ParentChangeCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeParentChangeCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeParentChangeCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeParentChangeCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeParentChangeCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::ParentChangeCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeTxTotalCountWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxTotalCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxTotalCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeTxTotalCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeTxTotalCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeTxTotalCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeTxTotalCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxTotalCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeTxUnicastCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxUnicastCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxUnicastCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeTxUnicastCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeTxUnicastCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeTxUnicastCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeTxUnicastCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxUnicastCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeTxBroadcastCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBroadcastCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBroadcastCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeTxBroadcastCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeTxBroadcastCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeTxBroadcastCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeTxBroadcastCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBroadcastCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeTxAckRequestedCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxAckRequestedCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxAckRequestedCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeTxAckRequestedCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeTxAckRequestedCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeTxAckRequestedCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeTxAckRequestedCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxAckRequestedCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeTxAckedCountWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxAckedCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxAckedCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeTxAckedCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeTxAckedCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeTxAckedCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeTxAckedCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxAckedCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeTxNoAckRequestedCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxNoAckRequestedCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxNoAckRequestedCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeTxNoAckRequestedCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeTxNoAckRequestedCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeTxNoAckRequestedCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler -{ - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeTxNoAckRequestedCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxNoAckRequestedCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeTxDataCountWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDataCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributeTxDataCountWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDataCount::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); } -- (void)subscribeAttributeTxDataCountWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)readAttributeTxDataPollCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeTxDataCount(success, failure, minInterval, maxInterval); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDataPollCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)reportAttributeTxDataCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeTxDataCount(success); - }, - true); -} - -- (void)readAttributeTxDataPollCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))completionHandler +- (void)subscribeAttributeTxDataPollCountWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDataPollCount::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); -} - -- (void)subscribeAttributeTxDataPollCountWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeTxDataPollCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeTxDataPollCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeTxDataPollCount(success); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeTxBeaconCountWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBeaconCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBeaconCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeTxBeaconCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeTxBeaconCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeTxBeaconCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeTxBeaconCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBeaconCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeTxBeaconRequestCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBeaconRequestCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBeaconRequestCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeTxBeaconRequestCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeTxBeaconRequestCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeTxBeaconRequestCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeTxBeaconRequestCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBeaconRequestCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeTxOtherCountWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxOtherCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxOtherCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeTxOtherCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeTxOtherCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeTxOtherCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeTxOtherCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxOtherCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeTxRetryCountWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxRetryCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxRetryCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeTxRetryCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeTxRetryCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeTxRetryCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeTxRetryCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxRetryCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeTxDirectMaxRetryExpiryCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDirectMaxRetryExpiryCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDirectMaxRetryExpiryCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeTxDirectMaxRetryExpiryCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeTxDirectMaxRetryExpiryCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeTxDirectMaxRetryExpiryCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler -{ - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeTxDirectMaxRetryExpiryCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDirectMaxRetryExpiryCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeTxIndirectMaxRetryExpiryCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxIndirectMaxRetryExpiryCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxIndirectMaxRetryExpiryCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeTxIndirectMaxRetryExpiryCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeTxIndirectMaxRetryExpiryCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeTxIndirectMaxRetryExpiryCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler -{ - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeTxIndirectMaxRetryExpiryCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxIndirectMaxRetryExpiryCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeTxErrCcaCountWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrCcaCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrCcaCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeTxErrCcaCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeTxErrCcaCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeTxErrCcaCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeTxErrCcaCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrCcaCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeTxErrAbortCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrAbortCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrAbortCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeTxErrAbortCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeTxErrAbortCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeTxErrAbortCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeTxErrAbortCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrAbortCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeTxErrBusyChannelCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrBusyChannelCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrBusyChannelCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeTxErrBusyChannelCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeTxErrBusyChannelCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeTxErrBusyChannelCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler -{ - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeTxErrBusyChannelCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrBusyChannelCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeRxTotalCountWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxTotalCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxTotalCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeRxTotalCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeRxTotalCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeRxTotalCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeRxTotalCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxTotalCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeRxUnicastCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxUnicastCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxUnicastCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeRxUnicastCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeRxUnicastCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeRxUnicastCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeRxUnicastCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxUnicastCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeRxBroadcastCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBroadcastCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBroadcastCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeRxBroadcastCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeRxBroadcastCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeRxBroadcastCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler -{ - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeRxBroadcastCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBroadcastCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeRxDataCountWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDataCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDataCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeRxDataCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeRxDataCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeRxDataCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeRxDataCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDataCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeRxDataPollCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDataPollCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDataPollCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeRxDataPollCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeRxDataPollCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeRxDataPollCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeRxDataPollCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDataPollCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeRxBeaconCountWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler -{ - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBeaconCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); -} - -- (void)subscribeAttributeRxBeaconCountWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeRxBeaconCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeRxBeaconCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeRxBeaconCount(success); - }, - true); +{ + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBeaconCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } -- (void)readAttributeRxBeaconRequestCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))completionHandler +- (void)subscribeAttributeRxBeaconCountWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBeaconRequestCount::TypeInfo; + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBeaconCount::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); } -- (void)subscribeAttributeRxBeaconRequestCountWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)readAttributeRxBeaconRequestCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeRxBeaconRequestCount(success, failure, minInterval, maxInterval); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBeaconRequestCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)reportAttributeRxBeaconRequestCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler +- (void)subscribeAttributeRxBeaconRequestCountWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeRxBeaconRequestCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBeaconRequestCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeRxOtherCountWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxOtherCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxOtherCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeRxOtherCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeRxOtherCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeRxOtherCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeRxOtherCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxOtherCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeRxAddressFilteredCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxAddressFilteredCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxAddressFilteredCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeRxAddressFilteredCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeRxAddressFilteredCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeRxAddressFilteredCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeRxAddressFilteredCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxAddressFilteredCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeRxDestAddrFilteredCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDestAddrFilteredCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDestAddrFilteredCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeRxDestAddrFilteredCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeRxDestAddrFilteredCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeRxDestAddrFilteredCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeRxDestAddrFilteredCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDestAddrFilteredCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeRxDuplicatedCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDuplicatedCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDuplicatedCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeRxDuplicatedCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeRxDuplicatedCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeRxDuplicatedCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeRxDuplicatedCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDuplicatedCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeRxErrNoFrameCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrNoFrameCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrNoFrameCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeRxErrNoFrameCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeRxErrNoFrameCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeRxErrNoFrameCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeRxErrNoFrameCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrNoFrameCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeRxErrUnknownNeighborCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrUnknownNeighborCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrUnknownNeighborCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeRxErrUnknownNeighborCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeRxErrUnknownNeighborCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeRxErrUnknownNeighborCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeRxErrUnknownNeighborCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrUnknownNeighborCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeRxErrInvalidSrcAddrCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrInvalidSrcAddrCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrInvalidSrcAddrCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeRxErrInvalidSrcAddrCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeRxErrInvalidSrcAddrCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeRxErrInvalidSrcAddrCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeRxErrInvalidSrcAddrCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrInvalidSrcAddrCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeRxErrSecCountWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrSecCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrSecCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeRxErrSecCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeRxErrSecCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeRxErrSecCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeRxErrSecCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrSecCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeRxErrFcsCountWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrFcsCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrFcsCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeRxErrFcsCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeRxErrFcsCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeRxErrFcsCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeRxErrFcsCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrFcsCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeRxErrOtherCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrOtherCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrOtherCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeRxErrOtherCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeRxErrOtherCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeRxErrOtherCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeRxErrOtherCount(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrOtherCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeActiveTimestampWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::ActiveTimestamp::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::ActiveTimestamp::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeActiveTimestampWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeActiveTimestamp(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeActiveTimestampWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeActiveTimestamp(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::ActiveTimestamp::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributePendingTimestampWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::PendingTimestamp::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::PendingTimestamp::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributePendingTimestampWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePendingTimestamp(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributePendingTimestampWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePendingTimestamp(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::PendingTimestamp::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeDelayWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::Delay::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::Delay::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeDelayWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeDelay(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeDelayWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeDelay(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::Delay::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeSecurityPolicyWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPThreadNetworkDiagnosticsSecurityPolicyListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = ThreadNetworkDiagnostics::Attributes::SecurityPolicy::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -25574,15 +21200,30 @@ new CHIPThreadNetworkDiagnosticsSecurityPolicyListAttributeCallbackBridge( }); } +- (void)subscribeAttributeSecurityPolicyWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + new CHIPThreadNetworkDiagnosticsSecurityPolicyListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::SecurityPolicy::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPThreadNetworkDiagnosticsSecurityPolicyListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); +} + - (void)readAttributeChannelMaskWithCompletionHandler:(void (^)( NSData * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPOctetStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = ThreadNetworkDiagnostics::Attributes::ChannelMask::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -25592,35 +21233,26 @@ new CHIPOctetStringAttributeCallbackBridge( - (void)subscribeAttributeChannelMaskWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPOctetStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeChannelMask(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeChannelMaskWithResponseHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPOctetStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPOctetStringAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeChannelMask(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::ChannelMask::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPOctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeOperationalDatasetComponentsWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPThreadNetworkDiagnosticsOperationalDatasetComponentsListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = ThreadNetworkDiagnostics::Attributes::OperationalDatasetComponents::TypeInfo; auto successFn = Callback::FromCancelable(success); @@ -25629,15 +21261,33 @@ new CHIPThreadNetworkDiagnosticsOperationalDatasetComponentsListAttributeCallbac }); } +- (void)subscribeAttributeOperationalDatasetComponentsWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSArray * _Nullable value, + NSError * _Nullable error))reportHandler +{ + new CHIPThreadNetworkDiagnosticsOperationalDatasetComponentsListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::OperationalDatasetComponents::TypeInfo; + auto successFn + = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPThreadNetworkDiagnosticsOperationalDatasetComponentsListAttributeCallbackSubscriptionBridge:: + OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); +} + - (void)readAttributeActiveNetworkFaultsListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = ThreadNetworkDiagnostics::Attributes::ActiveNetworkFaultsList::TypeInfo; auto successFn = Callback::FromCancelable(success); @@ -25646,15 +21296,33 @@ new CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackBrid }); } +- (void)subscribeAttributeActiveNetworkFaultsListWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + new CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::ActiveNetworkFaultsList::TypeInfo; + auto successFn + = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, + CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackSubscriptionBridge:: + OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); +} + - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPThreadNetworkDiagnosticsAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = ThreadNetworkDiagnostics::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -25665,56 +21333,41 @@ new CHIPThreadNetworkDiagnosticsAttributeListListAttributeCallbackBridge( - (void)readAttributeFeatureMapWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::FeatureMap::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::FeatureMap::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = ThreadNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = ThreadNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = ThreadNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -25729,51 +21382,38 @@ @implementation CHIPWakeOnLan - (void)readAttributeWakeOnLanMacAddressWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WakeOnLan::Attributes::WakeOnLanMacAddress::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WakeOnLan::Attributes::WakeOnLanMacAddress::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeWakeOnLanMacAddressWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeWakeOnLanMacAddress(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeWakeOnLanMacAddressWithResponseHandler:(void (^)(NSString * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPCharStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPCharStringAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeWakeOnLanMacAddress(success); + using TypeInfo = WakeOnLan::Attributes::WakeOnLanMacAddress::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPWakeOnLanAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = WakeOnLan::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -25784,40 +21424,30 @@ new CHIPWakeOnLanAttributeListListAttributeCallbackBridge( - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WakeOnLan::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WakeOnLan::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = WakeOnLan::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -25836,7 +21466,7 @@ - (void)resetCountsWithCompletionHandler:(StatusCompletion)completionHandler new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -25849,11 +21479,7 @@ new CHIPCommandSuccessCallbackBridge( - (void)readAttributeBssidWithCompletionHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPOctetStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = WiFiNetworkDiagnostics::Attributes::Bssid::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -25863,501 +21489,373 @@ new CHIPOctetStringAttributeCallbackBridge( - (void)subscribeAttributeBssidWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPOctetStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeBssid(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeBssidWithResponseHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPOctetStringAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPOctetStringAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeBssid(success); + using TypeInfo = WiFiNetworkDiagnostics::Attributes::Bssid::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPOctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeSecurityTypeWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WiFiNetworkDiagnostics::Attributes::SecurityType::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WiFiNetworkDiagnostics::Attributes::SecurityType::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeSecurityTypeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeSecurityType(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeSecurityTypeWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeSecurityType(success); + using TypeInfo = WiFiNetworkDiagnostics::Attributes::SecurityType::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeWiFiVersionWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WiFiNetworkDiagnostics::Attributes::WiFiVersion::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WiFiNetworkDiagnostics::Attributes::WiFiVersion::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeWiFiVersionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeWiFiVersion(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeWiFiVersionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeWiFiVersion(success); + using TypeInfo = WiFiNetworkDiagnostics::Attributes::WiFiVersion::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeChannelNumberWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WiFiNetworkDiagnostics::Attributes::ChannelNumber::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WiFiNetworkDiagnostics::Attributes::ChannelNumber::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeChannelNumberWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeChannelNumber(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeChannelNumberWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeChannelNumber(success); + using TypeInfo = WiFiNetworkDiagnostics::Attributes::ChannelNumber::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeRssiWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WiFiNetworkDiagnostics::Attributes::Rssi::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8sAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WiFiNetworkDiagnostics::Attributes::Rssi::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeRssiWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeRssi(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeRssiWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8sAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8sAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeRssi(success); + using TypeInfo = WiFiNetworkDiagnostics::Attributes::Rssi::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeBeaconLostCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WiFiNetworkDiagnostics::Attributes::BeaconLostCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WiFiNetworkDiagnostics::Attributes::BeaconLostCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeBeaconLostCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeBeaconLostCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeBeaconLostCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeBeaconLostCount(success); - }, - true); -} - -- (void)readAttributeBeaconRxCountWithCompletionHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))completionHandler -{ - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WiFiNetworkDiagnostics::Attributes::BeaconRxCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); -} - -- (void)subscribeAttributeBeaconRxCountWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeBeaconRxCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeBeaconRxCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeBeaconRxCount(success); - }, - true); -} - -- (void)readAttributePacketMulticastRxCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))completionHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketMulticastRxCount::TypeInfo; + using TypeInfo = WiFiNetworkDiagnostics::Attributes::BeaconLostCount::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); } -- (void)subscribeAttributePacketMulticastRxCountWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)readAttributeBeaconRxCountWithCompletionHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePacketMulticastRxCount(success, failure, minInterval, maxInterval); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WiFiNetworkDiagnostics::Attributes::BeaconRxCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)reportAttributePacketMulticastRxCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler +- (void)subscribeAttributeBeaconRxCountWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePacketMulticastRxCount(success); + using TypeInfo = WiFiNetworkDiagnostics::Attributes::BeaconRxCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } -- (void)readAttributePacketMulticastTxCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, +- (void)readAttributePacketMulticastRxCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketMulticastRxCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributePacketMulticastRxCountWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketMulticastTxCount::TypeInfo; + using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketMulticastRxCount::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); } -- (void)subscribeAttributePacketMulticastTxCountWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)readAttributePacketMulticastTxCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePacketMulticastTxCount(success, failure, minInterval, maxInterval); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketMulticastTxCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)reportAttributePacketMulticastTxCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler +- (void)subscribeAttributePacketMulticastTxCountWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePacketMulticastTxCount(success); + using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketMulticastTxCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributePacketUnicastRxCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketUnicastRxCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketUnicastRxCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributePacketUnicastRxCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePacketUnicastRxCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributePacketUnicastRxCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePacketUnicastRxCount(success); + using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketUnicastRxCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributePacketUnicastTxCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketUnicastTxCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketUnicastTxCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributePacketUnicastTxCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributePacketUnicastTxCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributePacketUnicastTxCountWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributePacketUnicastTxCount(success); + using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketUnicastTxCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeCurrentMaxRateWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WiFiNetworkDiagnostics::Attributes::CurrentMaxRate::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WiFiNetworkDiagnostics::Attributes::CurrentMaxRate::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeCurrentMaxRateWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCurrentMaxRate(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeCurrentMaxRateWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCurrentMaxRate(success); + using TypeInfo = WiFiNetworkDiagnostics::Attributes::CurrentMaxRate::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeOverrunCountWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WiFiNetworkDiagnostics::Attributes::OverrunCount::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WiFiNetworkDiagnostics::Attributes::OverrunCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeOverrunCountWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeOverrunCount(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeOverrunCountWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt64uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt64uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeOverrunCount(success); + using TypeInfo = WiFiNetworkDiagnostics::Attributes::OverrunCount::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPWiFiNetworkDiagnosticsAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = WiFiNetworkDiagnostics::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -26368,56 +21866,41 @@ new CHIPWiFiNetworkDiagnosticsAttributeListListAttributeCallbackBridge( - (void)readAttributeFeatureMapWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WiFiNetworkDiagnostics::Attributes::FeatureMap::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WiFiNetworkDiagnostics::Attributes::FeatureMap::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WiFiNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WiFiNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = WiFiNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end @@ -26436,7 +21919,7 @@ - (void)downOrCloseWithCompletionHandler:(StatusCompletion)completionHandler new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -26456,7 +21939,7 @@ - (void)goToLiftPercentageWithParams:(CHIPWindowCoveringClusterGoToLiftPercentag new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -26475,7 +21958,7 @@ - (void)goToLiftValueWithParams:(CHIPWindowCoveringClusterGoToLiftValueParams *) new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -26495,7 +21978,7 @@ - (void)goToTiltPercentageWithParams:(CHIPWindowCoveringClusterGoToTiltPercentag new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -26514,7 +21997,7 @@ - (void)goToTiltValueWithParams:(CHIPWindowCoveringClusterGoToTiltValueParams *) new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -26531,7 +22014,7 @@ - (void)stopMotionWithCompletionHandler:(StatusCompletion)completionHandler new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -26548,7 +22031,7 @@ - (void)upOrOpenWithCompletionHandler:(StatusCompletion)completionHandler new CHIPCommandSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { + ^(id _Nullable value, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -26560,646 +22043,492 @@ new CHIPCommandSuccessCallbackBridge( - (void)readAttributeTypeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WindowCovering::Attributes::Type::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WindowCovering::Attributes::Type::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeTypeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeType(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeTypeWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeType(success); + using TypeInfo = WindowCovering::Attributes::Type::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeCurrentPositionLiftWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WindowCovering::Attributes::CurrentPositionLift::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WindowCovering::Attributes::CurrentPositionLift::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeCurrentPositionLiftWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCurrentPositionLift(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeCurrentPositionLiftWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCurrentPositionLift(success); + using TypeInfo = WindowCovering::Attributes::CurrentPositionLift::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeCurrentPositionTiltWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WindowCovering::Attributes::CurrentPositionTilt::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WindowCovering::Attributes::CurrentPositionTilt::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeCurrentPositionTiltWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCurrentPositionTilt(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeCurrentPositionTiltWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCurrentPositionTilt(success); + using TypeInfo = WindowCovering::Attributes::CurrentPositionTilt::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeConfigStatusWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WindowCovering::Attributes::ConfigStatus::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WindowCovering::Attributes::ConfigStatus::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeConfigStatusWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeConfigStatus(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeConfigStatusWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeConfigStatus(success); + using TypeInfo = WindowCovering::Attributes::ConfigStatus::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeCurrentPositionLiftPercentageWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WindowCovering::Attributes::CurrentPositionLiftPercentage::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WindowCovering::Attributes::CurrentPositionLiftPercentage::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeCurrentPositionLiftPercentageWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCurrentPositionLiftPercentage(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeCurrentPositionLiftPercentageWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler -{ - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCurrentPositionLiftPercentage(success); + using TypeInfo = WindowCovering::Attributes::CurrentPositionLiftPercentage::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeCurrentPositionTiltPercentageWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WindowCovering::Attributes::CurrentPositionTiltPercentage::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); -} - -- (void)subscribeAttributeCurrentPositionTiltPercentageWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCurrentPositionTiltPercentage(success, failure, minInterval, maxInterval); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WindowCovering::Attributes::CurrentPositionTiltPercentage::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)reportAttributeCurrentPositionTiltPercentageWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler -{ - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCurrentPositionTiltPercentage(success); - }, - true); -} - -- (void)readAttributeOperationalStatusWithCompletionHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))completionHandler +- (void)subscribeAttributeCurrentPositionTiltPercentageWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WindowCovering::Attributes::OperationalStatus::TypeInfo; + using TypeInfo = WindowCovering::Attributes::CurrentPositionTiltPercentage::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); + }, + subscriptionEstablishedHandler); } -- (void)subscribeAttributeOperationalStatusWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)readAttributeOperationalStatusWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeOperationalStatus(success, failure, minInterval, maxInterval); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WindowCovering::Attributes::OperationalStatus::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)reportAttributeOperationalStatusWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler +- (void)subscribeAttributeOperationalStatusWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeOperationalStatus(success); + using TypeInfo = WindowCovering::Attributes::OperationalStatus::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeTargetPositionLiftPercent100thsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WindowCovering::Attributes::TargetPositionLiftPercent100ths::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WindowCovering::Attributes::TargetPositionLiftPercent100ths::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeTargetPositionLiftPercent100thsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeTargetPositionLiftPercent100ths(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeTargetPositionLiftPercent100thsWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeTargetPositionLiftPercent100ths(success); + using TypeInfo = WindowCovering::Attributes::TargetPositionLiftPercent100ths::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeTargetPositionTiltPercent100thsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WindowCovering::Attributes::TargetPositionTiltPercent100ths::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WindowCovering::Attributes::TargetPositionTiltPercent100ths::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeTargetPositionTiltPercent100thsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeTargetPositionTiltPercent100ths(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeTargetPositionTiltPercent100thsWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeTargetPositionTiltPercent100ths(success); + using TypeInfo = WindowCovering::Attributes::TargetPositionTiltPercent100ths::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeEndProductTypeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WindowCovering::Attributes::EndProductType::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WindowCovering::Attributes::EndProductType::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeEndProductTypeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeEndProductType(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeEndProductTypeWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeEndProductType(success); + using TypeInfo = WindowCovering::Attributes::EndProductType::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeCurrentPositionLiftPercent100thsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WindowCovering::Attributes::CurrentPositionLiftPercent100ths::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WindowCovering::Attributes::CurrentPositionLiftPercent100ths::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeCurrentPositionLiftPercent100thsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCurrentPositionLiftPercent100ths(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeCurrentPositionLiftPercent100thsWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCurrentPositionLiftPercent100ths(success); + using TypeInfo = WindowCovering::Attributes::CurrentPositionLiftPercent100ths::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeCurrentPositionTiltPercent100thsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WindowCovering::Attributes::CurrentPositionTiltPercent100ths::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WindowCovering::Attributes::CurrentPositionTiltPercent100ths::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeCurrentPositionTiltPercent100thsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCurrentPositionTiltPercent100ths(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeCurrentPositionTiltPercent100thsWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCurrentPositionTiltPercent100ths(success); + using TypeInfo = WindowCovering::Attributes::CurrentPositionTiltPercent100ths::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeInstalledOpenLimitLiftWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WindowCovering::Attributes::InstalledOpenLimitLift::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WindowCovering::Attributes::InstalledOpenLimitLift::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeInstalledOpenLimitLiftWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeInstalledOpenLimitLift(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeInstalledOpenLimitLiftWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeInstalledOpenLimitLift(success); + using TypeInfo = WindowCovering::Attributes::InstalledOpenLimitLift::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeInstalledClosedLimitLiftWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WindowCovering::Attributes::InstalledClosedLimitLift::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WindowCovering::Attributes::InstalledClosedLimitLift::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeInstalledClosedLimitLiftWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeInstalledClosedLimitLift(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeInstalledClosedLimitLiftWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler -{ - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeInstalledClosedLimitLift(success); + using TypeInfo = WindowCovering::Attributes::InstalledClosedLimitLift::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeInstalledOpenLimitTiltWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WindowCovering::Attributes::InstalledOpenLimitTilt::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WindowCovering::Attributes::InstalledOpenLimitTilt::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeInstalledOpenLimitTiltWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeInstalledOpenLimitTilt(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeInstalledOpenLimitTiltWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeInstalledOpenLimitTilt(success); + using TypeInfo = WindowCovering::Attributes::InstalledOpenLimitTilt::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeInstalledClosedLimitTiltWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WindowCovering::Attributes::InstalledClosedLimitTilt::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WindowCovering::Attributes::InstalledClosedLimitTilt::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeInstalledClosedLimitTiltWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeInstalledClosedLimitTilt(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeInstalledClosedLimitTiltWithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler + subscriptionEstablished: + (SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeInstalledClosedLimitTilt(success); + using TypeInfo = WindowCovering::Attributes::InstalledClosedLimitTilt::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WindowCovering::Attributes::Mode::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WindowCovering::Attributes::Mode::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)writeAttributeModeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -27215,74 +22544,54 @@ new CHIPDefaultSuccessCallbackBridge( - (void)subscribeAttributeModeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeMode(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeModeWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt8uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt8uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeMode(success); + using TypeInfo = WindowCovering::Attributes::Mode::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeSafetyStatusWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WindowCovering::Attributes::SafetyStatus::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WindowCovering::Attributes::SafetyStatus::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeSafetyStatusWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeSafetyStatus(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeSafetyStatusWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler -{ - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeSafetyStatus(success); + using TypeInfo = WindowCovering::Attributes::SafetyStatus::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeAttributeListWithCompletionHandler:(void (^)( NSArray * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPWindowCoveringAttributeListListAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { + self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { using TypeInfo = WindowCovering::Attributes::AttributeList::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -27293,79 +22602,58 @@ new CHIPWindowCoveringAttributeListListAttributeCallbackBridge( - (void)readAttributeFeatureMapWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WindowCovering::Attributes::FeatureMap::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WindowCovering::Attributes::FeatureMap::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeFeatureMapWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeFeatureMap(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeFeatureMapWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt32uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt32uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeFeatureMap(success); + using TypeInfo = WindowCovering::Attributes::FeatureMap::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); - }, - ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = WindowCovering::Attributes::ClusterRevision::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, completionHandler, ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = WindowCovering::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); } - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler -{ - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeClusterRevision(success, failure, minInterval, maxInterval); - }); -} - -- (void)reportAttributeClusterRevisionWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler + subscriptionEstablished:(SubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler + reportHandler: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler { - new CHIPInt16uAttributeCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable value) { - responseHandler(value, error); - }, + new CHIPInt16uAttributeCallbackSubscriptionBridge( + self.callbackQueue, reportHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeClusterRevision(success); + using TypeInfo = WindowCovering::Attributes::ClusterRevision::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.SubscribeAttribute(successFn->mContext, successFn->mCall, failureFn->mCall, + minInterval, maxInterval, CHIPInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished); }, - true); + subscriptionEstablishedHandler); } @end diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPTestClustersObjc.mm b/src/darwin/Framework/CHIP/zap-generated/CHIPTestClustersObjc.mm index 3ffdf39e898ccd..850e7fd439b451 100644 --- a/src/darwin/Framework/CHIP/zap-generated/CHIPTestClustersObjc.mm +++ b/src/darwin/Framework/CHIP/zap-generated/CHIPTestClustersObjc.mm @@ -48,7 +48,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -87,7 +87,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -118,7 +118,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -157,7 +157,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -188,7 +188,7 @@ - (void)writeAttributeWindowStatusWithValue:(NSNumber * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -206,7 +206,7 @@ - (void)writeAttributeAdminFabricIndexWithValue:(NSNumber * _Nonnull)value compl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -224,7 +224,7 @@ - (void)writeAttributeAdminVendorIdWithValue:(NSNumber * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -242,7 +242,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -281,7 +281,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -312,7 +312,7 @@ - (void)writeAttributeVendorNameWithValue:(NSString * _Nonnull)value completionH { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -330,7 +330,7 @@ - (void)writeAttributeVendorIdWithValue:(NSNumber * _Nonnull)value completionHan { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -348,7 +348,7 @@ - (void)writeAttributeApplicationNameWithValue:(NSString * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -366,7 +366,7 @@ - (void)writeAttributeProductIdWithValue:(NSNumber * _Nonnull)value completionHa { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -384,7 +384,7 @@ - (void)writeAttributeApplicationIdWithValue:(NSString * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -402,7 +402,7 @@ - (void)writeAttributeCatalogVendorIdWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -420,7 +420,7 @@ - (void)writeAttributeApplicationStatusWithValue:(NSNumber * _Nonnull)value comp { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -438,7 +438,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -477,7 +477,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -509,7 +509,7 @@ - (void)writeAttributeApplicationLauncherListWithValue:(NSArray * _Nonnull)value { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -548,7 +548,7 @@ - (void)writeAttributeCatalogVendorIdWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -566,7 +566,7 @@ - (void)writeAttributeApplicationIdWithValue:(NSNumber * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -584,7 +584,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -623,7 +623,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -654,7 +654,7 @@ - (void)writeAttributeAudioOutputListWithValue:(NSArray * _Nonnull)value complet { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -697,7 +697,7 @@ - (void)writeAttributeCurrentAudioOutputWithValue:(NSNumber * _Nonnull)value com { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -715,7 +715,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -754,7 +754,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -785,7 +785,7 @@ - (void)writeAttributeBarrierMovingStateWithValue:(NSNumber * _Nonnull)value com { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -803,7 +803,7 @@ - (void)writeAttributeBarrierSafetyStatusWithValue:(NSNumber * _Nonnull)value co { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -821,7 +821,7 @@ - (void)writeAttributeBarrierCapabilitiesWithValue:(NSNumber * _Nonnull)value co { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -839,7 +839,7 @@ - (void)writeAttributeBarrierPositionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -857,7 +857,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -896,7 +896,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -928,7 +928,7 @@ - (void)writeAttributeInteractionModelVersionWithValue:(NSNumber * _Nonnull)valu { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -946,7 +946,7 @@ - (void)writeAttributeVendorNameWithValue:(NSString * _Nonnull)value completionH { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -964,7 +964,7 @@ - (void)writeAttributeVendorIDWithValue:(NSNumber * _Nonnull)value completionHan { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -982,7 +982,7 @@ - (void)writeAttributeProductNameWithValue:(NSString * _Nonnull)value completion { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1000,7 +1000,7 @@ - (void)writeAttributeProductIDWithValue:(NSNumber * _Nonnull)value completionHa { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1018,7 +1018,7 @@ - (void)writeAttributeHardwareVersionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1037,7 +1037,7 @@ - (void)writeAttributeHardwareVersionStringWithValue:(NSString * _Nonnull)value { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1055,7 +1055,7 @@ - (void)writeAttributeSoftwareVersionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1074,7 +1074,7 @@ - (void)writeAttributeSoftwareVersionStringWithValue:(NSString * _Nonnull)value { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1092,7 +1092,7 @@ - (void)writeAttributeManufacturingDateWithValue:(NSString * _Nonnull)value comp { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1110,7 +1110,7 @@ - (void)writeAttributePartNumberWithValue:(NSString * _Nonnull)value completionH { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1128,7 +1128,7 @@ - (void)writeAttributeProductURLWithValue:(NSString * _Nonnull)value completionH { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1146,7 +1146,7 @@ - (void)writeAttributeProductLabelWithValue:(NSString * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1164,7 +1164,7 @@ - (void)writeAttributeSerialNumberWithValue:(NSString * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1182,7 +1182,7 @@ - (void)writeAttributeReachableWithValue:(NSNumber * _Nonnull)value completionHa { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1200,7 +1200,7 @@ - (void)writeAttributeUniqueIDWithValue:(NSString * _Nonnull)value completionHan { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1218,7 +1218,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1257,7 +1257,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1288,7 +1288,7 @@ - (void)writeAttributeStatusFlagsWithValue:(NSNumber * _Nonnull)value completion { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1306,7 +1306,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1345,7 +1345,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1376,7 +1376,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1415,7 +1415,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1446,7 +1446,7 @@ - (void)writeAttributeStateValueWithValue:(NSNumber * _Nonnull)value completionH { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1464,7 +1464,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1503,7 +1503,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1534,7 +1534,7 @@ - (void)writeAttributeActionListWithValue:(NSArray * _Nonnull)value completionHa { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1582,7 +1582,7 @@ - (void)writeAttributeEndpointListWithValue:(NSArray * _Nonnull)value completion { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1647,7 +1647,7 @@ - (void)writeAttributeSetupUrlWithValue:(NSString * _Nonnull)value completionHan { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1665,7 +1665,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1704,7 +1704,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1735,7 +1735,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1774,7 +1774,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1805,7 +1805,7 @@ - (void)writeAttributeCurrentHueWithValue:(NSNumber * _Nonnull)value completionH { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1823,7 +1823,7 @@ - (void)writeAttributeCurrentSaturationWithValue:(NSNumber * _Nonnull)value comp { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1841,7 +1841,7 @@ - (void)writeAttributeRemainingTimeWithValue:(NSNumber * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1859,7 +1859,7 @@ - (void)writeAttributeCurrentXWithValue:(NSNumber * _Nonnull)value completionHan { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1877,7 +1877,7 @@ - (void)writeAttributeCurrentYWithValue:(NSNumber * _Nonnull)value completionHan { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1895,7 +1895,7 @@ - (void)writeAttributeDriftCompensationWithValue:(NSNumber * _Nonnull)value comp { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1913,7 +1913,7 @@ - (void)writeAttributeCompensationTextWithValue:(NSString * _Nonnull)value compl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1931,7 +1931,7 @@ - (void)writeAttributeColorTemperatureWithValue:(NSNumber * _Nonnull)value compl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1949,7 +1949,7 @@ - (void)writeAttributeColorModeWithValue:(NSNumber * _Nonnull)value completionHa { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1967,7 +1967,7 @@ - (void)writeAttributeNumberOfPrimariesWithValue:(NSNumber * _Nonnull)value comp { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -1985,7 +1985,7 @@ - (void)writeAttributePrimary1XWithValue:(NSNumber * _Nonnull)value completionHa { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2003,7 +2003,7 @@ - (void)writeAttributePrimary1YWithValue:(NSNumber * _Nonnull)value completionHa { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2021,7 +2021,7 @@ - (void)writeAttributePrimary1IntensityWithValue:(NSNumber * _Nonnull)value comp { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2039,7 +2039,7 @@ - (void)writeAttributePrimary2XWithValue:(NSNumber * _Nonnull)value completionHa { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2057,7 +2057,7 @@ - (void)writeAttributePrimary2YWithValue:(NSNumber * _Nonnull)value completionHa { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2075,7 +2075,7 @@ - (void)writeAttributePrimary2IntensityWithValue:(NSNumber * _Nonnull)value comp { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2093,7 +2093,7 @@ - (void)writeAttributePrimary3XWithValue:(NSNumber * _Nonnull)value completionHa { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2111,7 +2111,7 @@ - (void)writeAttributePrimary3YWithValue:(NSNumber * _Nonnull)value completionHa { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2129,7 +2129,7 @@ - (void)writeAttributePrimary3IntensityWithValue:(NSNumber * _Nonnull)value comp { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2147,7 +2147,7 @@ - (void)writeAttributePrimary4XWithValue:(NSNumber * _Nonnull)value completionHa { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2165,7 +2165,7 @@ - (void)writeAttributePrimary4YWithValue:(NSNumber * _Nonnull)value completionHa { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2183,7 +2183,7 @@ - (void)writeAttributePrimary4IntensityWithValue:(NSNumber * _Nonnull)value comp { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2201,7 +2201,7 @@ - (void)writeAttributePrimary5XWithValue:(NSNumber * _Nonnull)value completionHa { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2219,7 +2219,7 @@ - (void)writeAttributePrimary5YWithValue:(NSNumber * _Nonnull)value completionHa { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2237,7 +2237,7 @@ - (void)writeAttributePrimary5IntensityWithValue:(NSNumber * _Nonnull)value comp { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2255,7 +2255,7 @@ - (void)writeAttributePrimary6XWithValue:(NSNumber * _Nonnull)value completionHa { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2273,7 +2273,7 @@ - (void)writeAttributePrimary6YWithValue:(NSNumber * _Nonnull)value completionHa { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2291,7 +2291,7 @@ - (void)writeAttributePrimary6IntensityWithValue:(NSNumber * _Nonnull)value comp { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2309,7 +2309,7 @@ - (void)writeAttributeEnhancedCurrentHueWithValue:(NSNumber * _Nonnull)value com { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2327,7 +2327,7 @@ - (void)writeAttributeEnhancedColorModeWithValue:(NSNumber * _Nonnull)value comp { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2345,7 +2345,7 @@ - (void)writeAttributeColorLoopActiveWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2363,7 +2363,7 @@ - (void)writeAttributeColorLoopDirectionWithValue:(NSNumber * _Nonnull)value com { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2381,7 +2381,7 @@ - (void)writeAttributeColorLoopTimeWithValue:(NSNumber * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2400,7 +2400,7 @@ - (void)writeAttributeColorLoopStartEnhancedHueWithValue:(NSNumber * _Nonnull)va { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2419,7 +2419,7 @@ - (void)writeAttributeColorLoopStoredEnhancedHueWithValue:(NSNumber * _Nonnull)v { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2437,7 +2437,7 @@ - (void)writeAttributeColorCapabilitiesWithValue:(NSNumber * _Nonnull)value comp { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2455,7 +2455,7 @@ - (void)writeAttributeColorTempPhysicalMinWithValue:(NSNumber * _Nonnull)value c { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2473,7 +2473,7 @@ - (void)writeAttributeColorTempPhysicalMaxWithValue:(NSNumber * _Nonnull)value c { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2492,7 +2492,7 @@ - (void)writeAttributeCoupleColorTempToLevelMinMiredsWithValue:(NSNumber * _Nonn { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2510,7 +2510,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2549,7 +2549,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2580,7 +2580,7 @@ - (void)writeAttributeAcceptsHeaderListWithValue:(NSArray * _Nonnull)value compl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2620,7 +2620,7 @@ - (void)writeAttributeSupportedStreamingTypesWithValue:(NSArray * _Nonnull)value { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2660,7 +2660,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2699,7 +2699,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2730,7 +2730,7 @@ - (void)writeAttributeDeviceListWithValue:(NSArray * _Nonnull)value completionHa { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2770,7 +2770,7 @@ - (void)writeAttributeServerListWithValue:(NSArray * _Nonnull)value completionHa { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2809,7 +2809,7 @@ - (void)writeAttributeClientListWithValue:(NSArray * _Nonnull)value completionHa { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2848,7 +2848,7 @@ - (void)writeAttributePartsListWithValue:(NSArray * _Nonnull)value completionHan { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2887,7 +2887,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2926,7 +2926,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -2957,7 +2957,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3009,7 +3009,7 @@ - (void)writeAttributeLockStateWithValue:(NSNumber * _Nullable)value completionH { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3032,7 +3032,7 @@ - (void)writeAttributeLockTypeWithValue:(NSNumber * _Nonnull)value completionHan { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3050,7 +3050,7 @@ - (void)writeAttributeActuatorEnabledWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3068,7 +3068,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3107,7 +3107,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3138,7 +3138,7 @@ - (void)writeAttributeMeasurementTypeWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3156,7 +3156,7 @@ - (void)writeAttributeTotalActivePowerWithValue:(NSNumber * _Nonnull)value compl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3174,7 +3174,7 @@ - (void)writeAttributeRmsVoltageWithValue:(NSNumber * _Nonnull)value completionH { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3192,7 +3192,7 @@ - (void)writeAttributeRmsVoltageMinWithValue:(NSNumber * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3210,7 +3210,7 @@ - (void)writeAttributeRmsVoltageMaxWithValue:(NSNumber * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3228,7 +3228,7 @@ - (void)writeAttributeRmsCurrentWithValue:(NSNumber * _Nonnull)value completionH { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3246,7 +3246,7 @@ - (void)writeAttributeRmsCurrentMinWithValue:(NSNumber * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3264,7 +3264,7 @@ - (void)writeAttributeRmsCurrentMaxWithValue:(NSNumber * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3282,7 +3282,7 @@ - (void)writeAttributeActivePowerWithValue:(NSNumber * _Nonnull)value completion { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3300,7 +3300,7 @@ - (void)writeAttributeActivePowerMinWithValue:(NSNumber * _Nonnull)value complet { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3318,7 +3318,7 @@ - (void)writeAttributeActivePowerMaxWithValue:(NSNumber * _Nonnull)value complet { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3336,7 +3336,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3375,7 +3375,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3406,7 +3406,7 @@ - (void)writeAttributePHYRateWithValue:(NSNumber * _Nonnull)value completionHand { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3424,7 +3424,7 @@ - (void)writeAttributeFullDuplexWithValue:(NSNumber * _Nonnull)value completionH { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3442,7 +3442,7 @@ - (void)writeAttributePacketRxCountWithValue:(NSNumber * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3460,7 +3460,7 @@ - (void)writeAttributePacketTxCountWithValue:(NSNumber * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3478,7 +3478,7 @@ - (void)writeAttributeTxErrCountWithValue:(NSNumber * _Nonnull)value completionH { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3496,7 +3496,7 @@ - (void)writeAttributeCollisionCountWithValue:(NSNumber * _Nonnull)value complet { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3514,7 +3514,7 @@ - (void)writeAttributeOverrunCountWithValue:(NSNumber * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3532,7 +3532,7 @@ - (void)writeAttributeCarrierDetectWithValue:(NSNumber * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3550,7 +3550,7 @@ - (void)writeAttributeTimeSinceResetWithValue:(NSNumber * _Nonnull)value complet { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3568,7 +3568,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3607,7 +3607,7 @@ - (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionH { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3625,7 +3625,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3656,7 +3656,7 @@ - (void)writeAttributeLabelListWithValue:(NSArray * _Nonnull)value completionHan { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3698,7 +3698,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3737,7 +3737,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3768,7 +3768,7 @@ - (void)writeAttributeMeasuredValueWithValue:(NSNumber * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3786,7 +3786,7 @@ - (void)writeAttributeMinMeasuredValueWithValue:(NSNumber * _Nonnull)value compl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3804,7 +3804,7 @@ - (void)writeAttributeMaxMeasuredValueWithValue:(NSNumber * _Nonnull)value compl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3822,7 +3822,7 @@ - (void)writeAttributeToleranceWithValue:(NSNumber * _Nonnull)value completionHa { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3840,7 +3840,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3879,7 +3879,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3911,7 +3911,7 @@ - (void)writeAttributeBasicCommissioningInfoListWithValue:(NSArray * _Nonnull)va { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3950,7 +3950,7 @@ - (void)writeAttributeRegulatoryConfigWithValue:(NSNumber * _Nonnull)value compl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3968,7 +3968,7 @@ - (void)writeAttributeLocationCapabilityWithValue:(NSNumber * _Nonnull)value com { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -3986,7 +3986,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4025,7 +4025,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4056,7 +4056,7 @@ - (void)writeAttributeNetworkInterfacesWithValue:(NSArray * _Nonnull)value compl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4104,7 +4104,7 @@ - (void)writeAttributeRebootCountWithValue:(NSNumber * _Nonnull)value completion { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4122,7 +4122,7 @@ - (void)writeAttributeUpTimeWithValue:(NSNumber * _Nonnull)value completionHandl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4141,7 +4141,7 @@ - (void)writeAttributeTotalOperationalHoursWithValue:(NSNumber * _Nonnull)value { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4159,7 +4159,7 @@ - (void)writeAttributeBootReasonsWithValue:(NSNumber * _Nonnull)value completion { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4177,7 +4177,7 @@ - (void)writeAttributeActiveHardwareFaultsWithValue:(NSArray * _Nonnull)value co { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4216,7 +4216,7 @@ - (void)writeAttributeActiveRadioFaultsWithValue:(NSArray * _Nonnull)value compl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4255,7 +4255,7 @@ - (void)writeAttributeActiveNetworkFaultsWithValue:(NSArray * _Nonnull)value com { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4294,7 +4294,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4333,7 +4333,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4364,7 +4364,7 @@ - (void)writeAttributeGroupsWithValue:(NSArray * _Nonnull)value completionHandle { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4405,7 +4405,7 @@ - (void)writeAttributeGroupKeysWithValue:(NSArray * _Nonnull)value completionHan { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4450,7 +4450,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4489,7 +4489,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4520,7 +4520,7 @@ - (void)writeAttributeNameSupportWithValue:(NSNumber * _Nonnull)value completion { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4538,7 +4538,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4577,7 +4577,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4608,7 +4608,7 @@ - (void)writeAttributeIdentifyTypeWithValue:(NSNumber * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4626,7 +4626,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4665,7 +4665,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4696,7 +4696,7 @@ - (void)writeAttributeMeasuredValueWithValue:(NSNumber * _Nullable)value complet { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4719,7 +4719,7 @@ - (void)writeAttributeMinMeasuredValueWithValue:(NSNumber * _Nullable)value comp { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4742,7 +4742,7 @@ - (void)writeAttributeMaxMeasuredValueWithValue:(NSNumber * _Nullable)value comp { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4765,7 +4765,7 @@ - (void)writeAttributeToleranceWithValue:(NSNumber * _Nonnull)value completionHa { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4783,7 +4783,7 @@ - (void)writeAttributeLightSensorTypeWithValue:(NSNumber * _Nullable)value compl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4806,7 +4806,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4845,7 +4845,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4876,7 +4876,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4915,7 +4915,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4946,7 +4946,7 @@ - (void)writeAttributeCurrentLevelWithValue:(NSNumber * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4964,7 +4964,7 @@ - (void)writeAttributeRemainingTimeWithValue:(NSNumber * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -4982,7 +4982,7 @@ - (void)writeAttributeMinLevelWithValue:(NSNumber * _Nonnull)value completionHan { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5000,7 +5000,7 @@ - (void)writeAttributeMaxLevelWithValue:(NSNumber * _Nonnull)value completionHan { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5018,7 +5018,7 @@ - (void)writeAttributeCurrentFrequencyWithValue:(NSNumber * _Nonnull)value compl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5036,7 +5036,7 @@ - (void)writeAttributeMinFrequencyWithValue:(NSNumber * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5054,7 +5054,7 @@ - (void)writeAttributeMaxFrequencyWithValue:(NSNumber * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5072,7 +5072,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5111,7 +5111,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5142,7 +5142,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5181,7 +5181,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5212,7 +5212,7 @@ - (void)writeAttributeMediaInputListWithValue:(NSArray * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5256,7 +5256,7 @@ - (void)writeAttributeCurrentMediaInputWithValue:(NSNumber * _Nonnull)value comp { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5274,7 +5274,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5313,7 +5313,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5344,7 +5344,7 @@ - (void)writeAttributePlaybackStateWithValue:(NSNumber * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5362,7 +5362,7 @@ - (void)writeAttributeStartTimeWithValue:(NSNumber * _Nonnull)value completionHa { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5380,7 +5380,7 @@ - (void)writeAttributeDurationWithValue:(NSNumber * _Nonnull)value completionHan { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5398,7 +5398,7 @@ - (void)writeAttributePositionUpdatedAtWithValue:(NSNumber * _Nonnull)value comp { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5416,7 +5416,7 @@ - (void)writeAttributePositionWithValue:(NSNumber * _Nonnull)value completionHan { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5434,7 +5434,7 @@ - (void)writeAttributePlaybackSpeedWithValue:(NSNumber * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5452,7 +5452,7 @@ - (void)writeAttributeSeekRangeEndWithValue:(NSNumber * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5470,7 +5470,7 @@ - (void)writeAttributeSeekRangeStartWithValue:(NSNumber * _Nonnull)value complet { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5488,7 +5488,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5527,7 +5527,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5558,7 +5558,7 @@ - (void)writeAttributeCurrentModeWithValue:(NSNumber * _Nonnull)value completion { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5576,7 +5576,7 @@ - (void)writeAttributeSupportedModesWithValue:(NSArray * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5617,7 +5617,7 @@ - (void)writeAttributeStartUpModeWithValue:(NSNumber * _Nonnull)value completion { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5635,7 +5635,7 @@ - (void)writeAttributeDescriptionWithValue:(NSString * _Nonnull)value completion { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5653,7 +5653,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5692,7 +5692,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5723,7 +5723,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5762,7 +5762,7 @@ - (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionH { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5780,7 +5780,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5811,7 +5811,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5850,7 +5850,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5881,7 +5881,7 @@ - (void)writeAttributeUpdatePossibleWithValue:(NSNumber * _Nonnull)value complet { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5899,7 +5899,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5938,7 +5938,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5969,7 +5969,7 @@ - (void)writeAttributeOccupancyWithValue:(NSNumber * _Nonnull)value completionHa { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -5987,7 +5987,7 @@ - (void)writeAttributeOccupancySensorTypeWithValue:(NSNumber * _Nonnull)value co { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6006,7 +6006,7 @@ - (void)writeAttributeOccupancySensorTypeBitmapWithValue:(NSNumber * _Nonnull)va { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6024,7 +6024,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6063,7 +6063,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6094,7 +6094,7 @@ - (void)writeAttributeOnOffWithValue:(NSNumber * _Nonnull)value completionHandle { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6112,7 +6112,7 @@ - (void)writeAttributeGlobalSceneControlWithValue:(NSNumber * _Nonnull)value com { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6130,7 +6130,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6169,7 +6169,7 @@ - (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionH { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6187,7 +6187,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6218,7 +6218,7 @@ - (void)writeAttributeSwitchTypeWithValue:(NSNumber * _Nonnull)value completionH { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6236,7 +6236,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6275,7 +6275,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6306,7 +6306,7 @@ - (void)writeAttributeFabricsListWithValue:(NSArray * _Nonnull)value completionH { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6350,7 +6350,7 @@ - (void)writeAttributeSupportedFabricsWithValue:(NSNumber * _Nonnull)value compl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6368,7 +6368,7 @@ - (void)writeAttributeCommissionedFabricsWithValue:(NSNumber * _Nonnull)value co { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6387,7 +6387,7 @@ - (void)writeAttributeTrustedRootCertificatesWithValue:(NSArray * _Nonnull)value { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6426,7 +6426,7 @@ - (void)writeAttributeCurrentFabricIndexWithValue:(NSNumber * _Nonnull)value com { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6444,7 +6444,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6483,7 +6483,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6514,7 +6514,7 @@ - (void)writeAttributeStatusWithValue:(NSNumber * _Nonnull)value completionHandl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6532,7 +6532,7 @@ - (void)writeAttributeOrderWithValue:(NSNumber * _Nonnull)value completionHandle { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6550,7 +6550,7 @@ - (void)writeAttributeDescriptionWithValue:(NSString * _Nonnull)value completion { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6568,7 +6568,7 @@ - (void)writeAttributeBatteryVoltageWithValue:(NSNumber * _Nonnull)value complet { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6587,7 +6587,7 @@ - (void)writeAttributeBatteryPercentRemainingWithValue:(NSNumber * _Nonnull)valu { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6605,7 +6605,7 @@ - (void)writeAttributeBatteryTimeRemainingWithValue:(NSNumber * _Nonnull)value c { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6623,7 +6623,7 @@ - (void)writeAttributeBatteryChargeLevelWithValue:(NSNumber * _Nonnull)value com { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6641,7 +6641,7 @@ - (void)writeAttributeActiveBatteryFaultsWithValue:(NSArray * _Nonnull)value com { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6680,7 +6680,7 @@ - (void)writeAttributeBatteryChargeStateWithValue:(NSNumber * _Nonnull)value com { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6698,7 +6698,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6737,7 +6737,7 @@ - (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionH { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6755,7 +6755,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6786,7 +6786,7 @@ - (void)writeAttributeSourcesWithValue:(NSArray * _Nonnull)value completionHandl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6825,7 +6825,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6864,7 +6864,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6895,7 +6895,7 @@ - (void)writeAttributeMeasuredValueWithValue:(NSNumber * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6913,7 +6913,7 @@ - (void)writeAttributeMinMeasuredValueWithValue:(NSNumber * _Nonnull)value compl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6931,7 +6931,7 @@ - (void)writeAttributeMaxMeasuredValueWithValue:(NSNumber * _Nonnull)value compl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6949,7 +6949,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -6988,7 +6988,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7019,7 +7019,7 @@ - (void)writeAttributeMaxPressureWithValue:(NSNumber * _Nonnull)value completion { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7037,7 +7037,7 @@ - (void)writeAttributeMaxSpeedWithValue:(NSNumber * _Nonnull)value completionHan { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7055,7 +7055,7 @@ - (void)writeAttributeMaxFlowWithValue:(NSNumber * _Nonnull)value completionHand { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7073,7 +7073,7 @@ - (void)writeAttributeMinConstPressureWithValue:(NSNumber * _Nonnull)value compl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7091,7 +7091,7 @@ - (void)writeAttributeMaxConstPressureWithValue:(NSNumber * _Nonnull)value compl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7109,7 +7109,7 @@ - (void)writeAttributeMinCompPressureWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7127,7 +7127,7 @@ - (void)writeAttributeMaxCompPressureWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7145,7 +7145,7 @@ - (void)writeAttributeMinConstSpeedWithValue:(NSNumber * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7163,7 +7163,7 @@ - (void)writeAttributeMaxConstSpeedWithValue:(NSNumber * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7181,7 +7181,7 @@ - (void)writeAttributeMinConstFlowWithValue:(NSNumber * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7199,7 +7199,7 @@ - (void)writeAttributeMaxConstFlowWithValue:(NSNumber * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7217,7 +7217,7 @@ - (void)writeAttributeMinConstTempWithValue:(NSNumber * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7235,7 +7235,7 @@ - (void)writeAttributeMaxConstTempWithValue:(NSNumber * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7253,7 +7253,7 @@ - (void)writeAttributePumpStatusWithValue:(NSNumber * _Nonnull)value completionH { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7272,7 +7272,7 @@ - (void)writeAttributeEffectiveOperationModeWithValue:(NSNumber * _Nonnull)value { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7290,7 +7290,7 @@ - (void)writeAttributeEffectiveControlModeWithValue:(NSNumber * _Nonnull)value c { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7308,7 +7308,7 @@ - (void)writeAttributeCapacityWithValue:(NSNumber * _Nonnull)value completionHan { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7326,7 +7326,7 @@ - (void)writeAttributeSpeedWithValue:(NSNumber * _Nonnull)value completionHandle { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7344,7 +7344,7 @@ - (void)writeAttributePowerWithValue:(NSNumber * _Nonnull)value completionHandle { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7362,7 +7362,7 @@ - (void)writeAttributeAlarmMaskWithValue:(NSNumber * _Nonnull)value completionHa { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7380,7 +7380,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7419,7 +7419,7 @@ - (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionH { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7437,7 +7437,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7468,7 +7468,7 @@ - (void)writeAttributeMeasuredValueWithValue:(NSNumber * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7486,7 +7486,7 @@ - (void)writeAttributeMinMeasuredValueWithValue:(NSNumber * _Nonnull)value compl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7504,7 +7504,7 @@ - (void)writeAttributeMaxMeasuredValueWithValue:(NSNumber * _Nonnull)value compl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7522,7 +7522,7 @@ - (void)writeAttributeToleranceWithValue:(NSNumber * _Nonnull)value completionHa { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7540,7 +7540,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7579,7 +7579,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7610,7 +7610,7 @@ - (void)writeAttributeSceneCountWithValue:(NSNumber * _Nonnull)value completionH { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7628,7 +7628,7 @@ - (void)writeAttributeCurrentSceneWithValue:(NSNumber * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7646,7 +7646,7 @@ - (void)writeAttributeCurrentGroupWithValue:(NSNumber * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7664,7 +7664,7 @@ - (void)writeAttributeSceneValidWithValue:(NSNumber * _Nonnull)value completionH { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7682,7 +7682,7 @@ - (void)writeAttributeNameSupportWithValue:(NSNumber * _Nonnull)value completion { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7700,7 +7700,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7739,7 +7739,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7770,7 +7770,7 @@ - (void)writeAttributeThreadMetricsWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7813,7 +7813,7 @@ - (void)writeAttributeCurrentHeapFreeWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7831,7 +7831,7 @@ - (void)writeAttributeCurrentHeapUsedWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7850,7 +7850,7 @@ - (void)writeAttributeCurrentHeapHighWatermarkWithValue:(NSNumber * _Nonnull)val { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7868,7 +7868,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7907,7 +7907,7 @@ - (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionH { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7925,7 +7925,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7956,7 +7956,7 @@ - (void)writeAttributeNumberOfPositionsWithValue:(NSNumber * _Nonnull)value comp { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7974,7 +7974,7 @@ - (void)writeAttributeCurrentPositionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -7992,7 +7992,7 @@ - (void)writeAttributeMultiPressMaxWithValue:(NSNumber * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -8010,7 +8010,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -8049,7 +8049,7 @@ - (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionH { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -8067,7 +8067,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -8098,7 +8098,7 @@ - (void)writeAttributeTvChannelListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -8141,7 +8141,7 @@ - (void)writeAttributeTvChannelLineupWithValue:(NSData * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -8159,7 +8159,7 @@ - (void)writeAttributeCurrentTvChannelWithValue:(NSData * _Nonnull)value complet { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -8177,7 +8177,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -8216,7 +8216,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -8247,7 +8247,7 @@ - (void)writeAttributeTargetNavigatorListWithValue:(NSArray * _Nonnull)value com { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -8287,7 +8287,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -8326,7 +8326,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -8357,7 +8357,7 @@ - (void)writeAttributeMeasuredValueWithValue:(NSNumber * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -8375,7 +8375,7 @@ - (void)writeAttributeMinMeasuredValueWithValue:(NSNumber * _Nonnull)value compl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -8393,7 +8393,7 @@ - (void)writeAttributeMaxMeasuredValueWithValue:(NSNumber * _Nonnull)value compl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -8411,7 +8411,7 @@ - (void)writeAttributeToleranceWithValue:(NSNumber * _Nonnull)value completionHa { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -8429,7 +8429,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -8468,7 +8468,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -8500,7 +8500,7 @@ - (void)writeAttributeListNullablesAndOptionalsStructWithValue:(NSArray * _Nonnu { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -8711,7 +8711,7 @@ - (void)writeAttributeListLongOctetStringWithValue:(NSArray * _Nonnull)value com { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -8750,7 +8750,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -8789,7 +8789,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -8820,7 +8820,7 @@ - (void)writeAttributeLocalTemperatureWithValue:(NSNumber * _Nonnull)value compl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -8839,7 +8839,7 @@ - (void)writeAttributeAbsMinHeatSetpointLimitWithValue:(NSNumber * _Nonnull)valu { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -8858,7 +8858,7 @@ - (void)writeAttributeAbsMaxHeatSetpointLimitWithValue:(NSNumber * _Nonnull)valu { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -8877,7 +8877,7 @@ - (void)writeAttributeAbsMinCoolSetpointLimitWithValue:(NSNumber * _Nonnull)valu { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -8896,7 +8896,7 @@ - (void)writeAttributeAbsMaxCoolSetpointLimitWithValue:(NSNumber * _Nonnull)valu { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -8914,7 +8914,7 @@ - (void)writeAttributeStartOfWeekWithValue:(NSNumber * _Nonnull)value completion { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -8933,7 +8933,7 @@ - (void)writeAttributeNumberOfWeeklyTransitionsWithValue:(NSNumber * _Nonnull)va { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -8952,7 +8952,7 @@ - (void)writeAttributeNumberOfDailyTransitionsWithValue:(NSNumber * _Nonnull)val { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -8970,7 +8970,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9009,7 +9009,7 @@ - (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionH { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9027,7 +9027,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9058,7 +9058,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9097,7 +9097,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9128,7 +9128,7 @@ - (void)writeAttributeChannelWithValue:(NSNumber * _Nonnull)value completionHand { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9146,7 +9146,7 @@ - (void)writeAttributeRoutingRoleWithValue:(NSNumber * _Nonnull)value completion { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9164,7 +9164,7 @@ - (void)writeAttributeNetworkNameWithValue:(NSData * _Nonnull)value completionHa { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9182,7 +9182,7 @@ - (void)writeAttributePanIdWithValue:(NSNumber * _Nonnull)value completionHandle { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9200,7 +9200,7 @@ - (void)writeAttributeExtendedPanIdWithValue:(NSNumber * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9218,7 +9218,7 @@ - (void)writeAttributeMeshLocalPrefixWithValue:(NSData * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9236,7 +9236,7 @@ - (void)writeAttributeOverrunCountWithValue:(NSNumber * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9254,7 +9254,7 @@ - (void)writeAttributeNeighborTableListWithValue:(NSArray * _Nonnull)value compl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9306,7 +9306,7 @@ - (void)writeAttributeRouteTableListWithValue:(NSArray * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9354,7 +9354,7 @@ - (void)writeAttributePartitionIdWithValue:(NSNumber * _Nonnull)value completion { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9372,7 +9372,7 @@ - (void)writeAttributeWeightingWithValue:(NSNumber * _Nonnull)value completionHa { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9390,7 +9390,7 @@ - (void)writeAttributeDataVersionWithValue:(NSNumber * _Nonnull)value completion { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9408,7 +9408,7 @@ - (void)writeAttributeStableDataVersionWithValue:(NSNumber * _Nonnull)value comp { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9426,7 +9426,7 @@ - (void)writeAttributeLeaderRouterIdWithValue:(NSNumber * _Nonnull)value complet { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9444,7 +9444,7 @@ - (void)writeAttributeDetachedRoleCountWithValue:(NSNumber * _Nonnull)value comp { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9462,7 +9462,7 @@ - (void)writeAttributeChildRoleCountWithValue:(NSNumber * _Nonnull)value complet { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9480,7 +9480,7 @@ - (void)writeAttributeRouterRoleCountWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9498,7 +9498,7 @@ - (void)writeAttributeLeaderRoleCountWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9516,7 +9516,7 @@ - (void)writeAttributeAttachAttemptCountWithValue:(NSNumber * _Nonnull)value com { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9535,7 +9535,7 @@ - (void)writeAttributePartitionIdChangeCountWithValue:(NSNumber * _Nonnull)value { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9554,7 +9554,7 @@ - (void)writeAttributeBetterPartitionAttachAttemptCountWithValue:(NSNumber * _No { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9572,7 +9572,7 @@ - (void)writeAttributeParentChangeCountWithValue:(NSNumber * _Nonnull)value comp { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9590,7 +9590,7 @@ - (void)writeAttributeTxTotalCountWithValue:(NSNumber * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9608,7 +9608,7 @@ - (void)writeAttributeTxUnicastCountWithValue:(NSNumber * _Nonnull)value complet { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9626,7 +9626,7 @@ - (void)writeAttributeTxBroadcastCountWithValue:(NSNumber * _Nonnull)value compl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9644,7 +9644,7 @@ - (void)writeAttributeTxAckRequestedCountWithValue:(NSNumber * _Nonnull)value co { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9662,7 +9662,7 @@ - (void)writeAttributeTxAckedCountWithValue:(NSNumber * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9681,7 +9681,7 @@ - (void)writeAttributeTxNoAckRequestedCountWithValue:(NSNumber * _Nonnull)value { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9699,7 +9699,7 @@ - (void)writeAttributeTxDataCountWithValue:(NSNumber * _Nonnull)value completion { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9717,7 +9717,7 @@ - (void)writeAttributeTxDataPollCountWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9735,7 +9735,7 @@ - (void)writeAttributeTxBeaconCountWithValue:(NSNumber * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9753,7 +9753,7 @@ - (void)writeAttributeTxBeaconRequestCountWithValue:(NSNumber * _Nonnull)value c { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9771,7 +9771,7 @@ - (void)writeAttributeTxOtherCountWithValue:(NSNumber * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9789,7 +9789,7 @@ - (void)writeAttributeTxRetryCountWithValue:(NSNumber * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9808,7 +9808,7 @@ - (void)writeAttributeTxDirectMaxRetryExpiryCountWithValue:(NSNumber * _Nonnull) { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9827,7 +9827,7 @@ - (void)writeAttributeTxIndirectMaxRetryExpiryCountWithValue:(NSNumber * _Nonnul { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9845,7 +9845,7 @@ - (void)writeAttributeTxErrCcaCountWithValue:(NSNumber * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9863,7 +9863,7 @@ - (void)writeAttributeTxErrAbortCountWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9882,7 +9882,7 @@ - (void)writeAttributeTxErrBusyChannelCountWithValue:(NSNumber * _Nonnull)value { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9900,7 +9900,7 @@ - (void)writeAttributeRxTotalCountWithValue:(NSNumber * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9918,7 +9918,7 @@ - (void)writeAttributeRxUnicastCountWithValue:(NSNumber * _Nonnull)value complet { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9936,7 +9936,7 @@ - (void)writeAttributeRxBroadcastCountWithValue:(NSNumber * _Nonnull)value compl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9954,7 +9954,7 @@ - (void)writeAttributeRxDataCountWithValue:(NSNumber * _Nonnull)value completion { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9972,7 +9972,7 @@ - (void)writeAttributeRxDataPollCountWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -9990,7 +9990,7 @@ - (void)writeAttributeRxBeaconCountWithValue:(NSNumber * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10008,7 +10008,7 @@ - (void)writeAttributeRxBeaconRequestCountWithValue:(NSNumber * _Nonnull)value c { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10026,7 +10026,7 @@ - (void)writeAttributeRxOtherCountWithValue:(NSNumber * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10045,7 +10045,7 @@ - (void)writeAttributeRxAddressFilteredCountWithValue:(NSNumber * _Nonnull)value { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10064,7 +10064,7 @@ - (void)writeAttributeRxDestAddrFilteredCountWithValue:(NSNumber * _Nonnull)valu { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10082,7 +10082,7 @@ - (void)writeAttributeRxDuplicatedCountWithValue:(NSNumber * _Nonnull)value comp { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10100,7 +10100,7 @@ - (void)writeAttributeRxErrNoFrameCountWithValue:(NSNumber * _Nonnull)value comp { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10119,7 +10119,7 @@ - (void)writeAttributeRxErrUnknownNeighborCountWithValue:(NSNumber * _Nonnull)va { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10138,7 +10138,7 @@ - (void)writeAttributeRxErrInvalidSrcAddrCountWithValue:(NSNumber * _Nonnull)val { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10156,7 +10156,7 @@ - (void)writeAttributeRxErrSecCountWithValue:(NSNumber * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10174,7 +10174,7 @@ - (void)writeAttributeRxErrFcsCountWithValue:(NSNumber * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10192,7 +10192,7 @@ - (void)writeAttributeRxErrOtherCountWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10210,7 +10210,7 @@ - (void)writeAttributeActiveTimestampWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10228,7 +10228,7 @@ - (void)writeAttributePendingTimestampWithValue:(NSNumber * _Nonnull)value compl { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10246,7 +10246,7 @@ - (void)writeAttributeDelayWithValue:(NSNumber * _Nonnull)value completionHandle { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10264,7 +10264,7 @@ - (void)writeAttributeSecurityPolicyWithValue:(NSArray * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10304,7 +10304,7 @@ - (void)writeAttributeChannelMaskWithValue:(NSData * _Nonnull)value completionHa { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10323,7 +10323,7 @@ - (void)writeAttributeOperationalDatasetComponentsWithValue:(NSArray * _Nonnull) { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10374,7 +10374,7 @@ - (void)writeAttributeActiveNetworkFaultsListWithValue:(NSArray * _Nonnull)value { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10414,7 +10414,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10453,7 +10453,7 @@ - (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionH { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10471,7 +10471,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10502,7 +10502,7 @@ - (void)writeAttributeWakeOnLanMacAddressWithValue:(NSString * _Nonnull)value co { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10520,7 +10520,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10559,7 +10559,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10590,7 +10590,7 @@ - (void)writeAttributeBssidWithValue:(NSData * _Nonnull)value completionHandler: { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10608,7 +10608,7 @@ - (void)writeAttributeSecurityTypeWithValue:(NSNumber * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10626,7 +10626,7 @@ - (void)writeAttributeWiFiVersionWithValue:(NSNumber * _Nonnull)value completion { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10644,7 +10644,7 @@ - (void)writeAttributeChannelNumberWithValue:(NSNumber * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10662,7 +10662,7 @@ - (void)writeAttributeRssiWithValue:(NSNumber * _Nonnull)value completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10680,7 +10680,7 @@ - (void)writeAttributeBeaconLostCountWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10698,7 +10698,7 @@ - (void)writeAttributeBeaconRxCountWithValue:(NSNumber * _Nonnull)value completi { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10717,7 +10717,7 @@ - (void)writeAttributePacketMulticastRxCountWithValue:(NSNumber * _Nonnull)value { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10736,7 +10736,7 @@ - (void)writeAttributePacketMulticastTxCountWithValue:(NSNumber * _Nonnull)value { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10754,7 +10754,7 @@ - (void)writeAttributePacketUnicastRxCountWithValue:(NSNumber * _Nonnull)value c { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10772,7 +10772,7 @@ - (void)writeAttributePacketUnicastTxCountWithValue:(NSNumber * _Nonnull)value c { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10790,7 +10790,7 @@ - (void)writeAttributeCurrentMaxRateWithValue:(NSNumber * _Nonnull)value complet { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10808,7 +10808,7 @@ - (void)writeAttributeOverrunCountWithValue:(NSNumber * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10826,7 +10826,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10865,7 +10865,7 @@ - (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionH { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10883,7 +10883,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10914,7 +10914,7 @@ - (void)writeAttributeTypeWithValue:(NSNumber * _Nonnull)value completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10932,7 +10932,7 @@ - (void)writeAttributeCurrentPositionLiftWithValue:(NSNumber * _Nonnull)value co { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10950,7 +10950,7 @@ - (void)writeAttributeCurrentPositionTiltWithValue:(NSNumber * _Nonnull)value co { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10968,7 +10968,7 @@ - (void)writeAttributeConfigStatusWithValue:(NSNumber * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -10987,7 +10987,7 @@ - (void)writeAttributeCurrentPositionLiftPercentageWithValue:(NSNumber * _Nonnul { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -11006,7 +11006,7 @@ - (void)writeAttributeCurrentPositionTiltPercentageWithValue:(NSNumber * _Nonnul { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -11024,7 +11024,7 @@ - (void)writeAttributeOperationalStatusWithValue:(NSNumber * _Nonnull)value comp { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -11043,7 +11043,7 @@ - (void)writeAttributeTargetPositionLiftPercent100thsWithValue:(NSNumber * _Nonn { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -11062,7 +11062,7 @@ - (void)writeAttributeTargetPositionTiltPercent100thsWithValue:(NSNumber * _Nonn { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -11080,7 +11080,7 @@ - (void)writeAttributeEndProductTypeWithValue:(NSNumber * _Nonnull)value complet { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -11099,7 +11099,7 @@ - (void)writeAttributeCurrentPositionLiftPercent100thsWithValue:(NSNumber * _Non { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -11118,7 +11118,7 @@ - (void)writeAttributeCurrentPositionTiltPercent100thsWithValue:(NSNumber * _Non { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -11137,7 +11137,7 @@ - (void)writeAttributeInstalledOpenLimitLiftWithValue:(NSNumber * _Nonnull)value { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -11156,7 +11156,7 @@ - (void)writeAttributeInstalledClosedLimitLiftWithValue:(NSNumber * _Nonnull)val { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -11175,7 +11175,7 @@ - (void)writeAttributeInstalledOpenLimitTiltWithValue:(NSNumber * _Nonnull)value { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -11194,7 +11194,7 @@ - (void)writeAttributeInstalledClosedLimitTiltWithValue:(NSNumber * _Nonnull)val { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -11212,7 +11212,7 @@ - (void)writeAttributeSafetyStatusWithValue:(NSNumber * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -11230,7 +11230,7 @@ - (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completio { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -11269,7 +11269,7 @@ - (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionH { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { @@ -11287,7 +11287,7 @@ - (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value comple { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { + ^(id _Nullable ignored, NSError * _Nullable error) { completionHandler(error); }, ^(Cancelable * success, Cancelable * failure) { diff --git a/src/darwin/Framework/CHIPTests/CHIPClustersTests.m b/src/darwin/Framework/CHIPTests/CHIPClustersTests.m index 0053144019cbd0..82590a8a846813 100644 --- a/src/darwin/Framework/CHIPTests/CHIPClustersTests.m +++ b/src/darwin/Framework/CHIPTests/CHIPClustersTests.m @@ -31380,6 +31380,7 @@ - (void)testSendClusterTestSubscribe_OnOff_000001_Off [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } bool testSendClusterTestSubscribe_OnOff_000002_WaitForReport_Fulfilled = false; +ResponseHandler test_TestSubscribe_OnOff_OnOff_Reported = nil; - (void)testSendClusterTestSubscribe_OnOff_000002_WaitForReport { @@ -31388,7 +31389,7 @@ - (void)testSendClusterTestSubscribe_OnOff_000002_WaitForReport CHIPTestOnOff * cluster = [[CHIPTestOnOff alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster reportAttributeOnOffWithResponseHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + test_TestSubscribe_OnOff_OnOff_Reported = ^(NSNumber * _Nullable value, NSError * _Nullable err) { NSLog(@"Report: Subscribe OnOff Attribute Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); @@ -31399,7 +31400,7 @@ - (void)testSendClusterTestSubscribe_OnOff_000002_WaitForReport } testSendClusterTestSubscribe_OnOff_000002_WaitForReport_Fulfilled = true; - }]; + }; } - (void)testSendClusterTestSubscribe_OnOff_000003_SubscribeAttribute { @@ -31413,14 +31414,21 @@ - (void)testSendClusterTestSubscribe_OnOff_000003_SubscribeAttribute uint16_t minIntervalArgument = 2U; uint16_t maxIntervalArgument = 10U; [cluster subscribeAttributeOnOffWithMinInterval:minIntervalArgument - maxInterval:maxIntervalArgument - responseHandler:^(NSError * err, NSDictionary * values) { - NSLog(@"Subscribe OnOff Attribute Error: %@", err); + maxInterval:maxIntervalArgument + subscriptionEstablished:^{ + XCTAssertEqual(testSendClusterTestSubscribe_OnOff_000002_WaitForReport_Fulfilled, true); + [expectation fulfill]; + } + reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Subscribe OnOff Attribute Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - XCTAssertEqual(testSendClusterTestSubscribe_OnOff_000002_WaitForReport_Fulfilled, true); - [expectation fulfill]; - }]; + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + if (test_TestSubscribe_OnOff_OnOff_Reported != nil) { + ResponseHandler callback = test_TestSubscribe_OnOff_OnOff_Reported; + test_TestSubscribe_OnOff_OnOff_Reported = nil; + callback(value, err); + } + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } @@ -31452,7 +31460,7 @@ - (void)testSendClusterTestSubscribe_OnOff_000005_WaitForReport CHIPTestOnOff * cluster = [[CHIPTestOnOff alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster reportAttributeOnOffWithResponseHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + test_TestSubscribe_OnOff_OnOff_Reported = ^(NSNumber * _Nullable value, NSError * _Nullable err) { NSLog(@"Check for attribute report Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); @@ -31463,7 +31471,7 @@ - (void)testSendClusterTestSubscribe_OnOff_000005_WaitForReport } [expectation fulfill]; - }]; + }; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } @@ -31495,7 +31503,7 @@ - (void)testSendClusterTestSubscribe_OnOff_000007_WaitForReport CHIPTestOnOff * cluster = [[CHIPTestOnOff alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster reportAttributeOnOffWithResponseHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + test_TestSubscribe_OnOff_OnOff_Reported = ^(NSNumber * _Nullable value, NSError * _Nullable err) { NSLog(@"Check for attribute report Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); @@ -31506,7 +31514,7 @@ - (void)testSendClusterTestSubscribe_OnOff_000007_WaitForReport } [expectation fulfill]; - }]; + }; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; }