examples/tv-app/tv-common/gen/CHIPClustersObjc.mm

   1 /*
   2  *
   3  *    Copyright (c) 2021 Project CHIP Authors
   4  *
   5  *    Licensed under the Apache License, Version 2.0 (the "License");
   6  *    you may not use this file except in compliance with the License.
   7  *    You may obtain a copy of the License at
   8  *
   9  *        http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *    Unless required by applicable law or agreed to in writing, software
  12  *    distributed under the License is distributed on an "AS IS" BASIS,
  13  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *    See the License for the specific language governing permissions and
  15  *    limitations under the License.
  16  */
  17
  18 // THIS FILE IS GENERATED BY ZAP
  19
  20 #import <Foundation/Foundation.h>
  21
  22 #import "CHIPDevice.h"
  23 #import "CHIPDevice_Internal.h"
  24 #import "CHIPError.h"
  25 #import "gen/CHIPClientCallbacks.h"
  26 #import "gen/CHIPClustersObjc.h"
  27
  28 #include <controller/CHIPClusters.h>
  29 #include <lib/support/Span.h>
  30
  31 using namespace ::chip;
  32
  33 class CHIPDefaultSuccessCallbackBridge : public Callback::Callback<DefaultSuccessCallback> {
  34 public:
  35     CHIPDefaultSuccessCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
  36         : Callback::Callback<DefaultSuccessCallback>(CallbackFn, this)
  37         , mHandler(handler)
  38         , mQueue(queue)
  39     {
  40     }
  41
  42     ~CHIPDefaultSuccessCallbackBridge() {};
  43
  44     static void CallbackFn(void * context)
  45     {
  46         CHIPDefaultSuccessCallbackBridge * callback = reinterpret_cast<CHIPDefaultSuccessCallbackBridge *>(context);
  47         if (callback && callback->mQueue) {
  48             dispatch_async(callback->mQueue, ^{
  49                 callback->mHandler(nil, nil);
  50                 callback->Cancel();
  51                 delete callback;
  52             });
  53         }
  54     };
  55
  56 private:
  57     ResponseHandler mHandler;
  58     dispatch_queue_t mQueue;
  59 };
  60
  61 class CHIPDefaultFailureCallbackBridge : public Callback::Callback<DefaultFailureCallback> {
  62 public:
  63     CHIPDefaultFailureCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
  64         : Callback::Callback<DefaultFailureCallback>(CallbackFn, this)
  65         , mHandler(handler)
  66         , mQueue(queue)
  67     {
  68     }
  69
  70     ~CHIPDefaultFailureCallbackBridge() {};
  71
  72     static void CallbackFn(void * context, uint8_t status)
  73     {
  74         CHIPDefaultFailureCallbackBridge * callback = reinterpret_cast<CHIPDefaultFailureCallbackBridge *>(context);
  75         if (callback && callback->mQueue) {
  76             dispatch_async(callback->mQueue, ^{
  77                 NSError * error = [CHIPError errorForCHIPErrorCode:status];
  78                 callback->mHandler(error, nil);
  79                 callback->Cancel();
  80                 delete callback;
  81             });
  82         }
  83     };
  84
  85 private:
  86     ResponseHandler mHandler;
  87     dispatch_queue_t mQueue;
  88 };
  89
  90 class CHIPStringAttributeCallbackBridge : public Callback::Callback<StringAttributeCallback> {
  91 public:
  92     CHIPStringAttributeCallbackBridge(ResponseHandler handler, dispatch_queue_t queue, bool octetString, bool keepAlive = false)
  93         : Callback::Callback<StringAttributeCallback>(CallbackFn, this)
  94         , mHandler(handler)
  95         , mQueue(queue)
  96         , mOctetString(octetString)
  97         , mKeepAlive(keepAlive)
  98     {
  99     }
 100
 101     ~CHIPStringAttributeCallbackBridge() {};
 102
 103     static void CallbackFn(void * context, chip::ByteSpan value)
 104     {
 105         CHIPStringAttributeCallbackBridge * callback = reinterpret_cast<CHIPStringAttributeCallbackBridge *>(context);
 106         if (callback && callback->mQueue) {
 107             dispatch_async(callback->mQueue, ^{
 108                 if (callback->mOctetString) {
 109                     NSData * data = [NSData dataWithBytes:value.data() length:value.size()];
 110                     callback->mHandler(nil, @ { @"value" : data });
 111                 } else {
 112                     NSString * str = [[NSString alloc] initWithBytes:value.data()
 113                                                               length:value.size()
 114                                                             encoding:NSUTF8StringEncoding];
 115                     callback->mHandler(nil, @ { @"value" : str });
 116                 }
 117
 118                 if (!callback->mKeepAlive) {
 119                     callback->Cancel();
 120                     delete callback;
 121                 }
 122             });
 123         }
 124     };
 125
 126 private:
 127     ResponseHandler mHandler;
 128     dispatch_queue_t mQueue;
 129     bool mOctetString;
 130     bool mKeepAlive;
 131 };
 132
 133 class CHIPBooleanAttributeCallbackBridge : public Callback::Callback<BooleanAttributeCallback> {
 134 public:
 135     CHIPBooleanAttributeCallbackBridge(ResponseHandler handler, dispatch_queue_t queue, bool keepAlive = false)
 136         : Callback::Callback<BooleanAttributeCallback>(CallbackFn, this)
 137         , mHandler(handler)
 138         , mQueue(queue)
 139         , mKeepAlive(keepAlive)
 140     {
 141     }
 142
 143     ~CHIPBooleanAttributeCallbackBridge() {};
 144
 145     static void CallbackFn(void * context, bool value)
 146     {
 147         CHIPBooleanAttributeCallbackBridge * callback = reinterpret_cast<CHIPBooleanAttributeCallbackBridge *>(context);
 148         if (callback && callback->mQueue) {
 149             dispatch_async(callback->mQueue, ^{
 150                 callback->mHandler(nil, @ { @"value" : [NSNumber numberWithBool:value] });
 151                 if (!callback->mKeepAlive) {
 152                     callback->Cancel();
 153                     delete callback;
 154                 }
 155             });
 156         }
 157     };
 158
 159 private:
 160     ResponseHandler mHandler;
 161     dispatch_queue_t mQueue;
 162     bool mKeepAlive;
 163 };
 164
 165 class CHIPInt8uAttributeCallbackBridge : public Callback::Callback<Int8uAttributeCallback> {
 166 public:
 167     CHIPInt8uAttributeCallbackBridge(ResponseHandler handler, dispatch_queue_t queue, bool keepAlive = false)
 168         : Callback::Callback<Int8uAttributeCallback>(CallbackFn, this)
 169         , mHandler(handler)
 170         , mQueue(queue)
 171         , mKeepAlive(keepAlive)
 172     {
 173     }
 174
 175     ~CHIPInt8uAttributeCallbackBridge() {};
 176
 177     static void CallbackFn(void * context, uint8_t value)
 178     {
 179         CHIPInt8uAttributeCallbackBridge * callback = reinterpret_cast<CHIPInt8uAttributeCallbackBridge *>(context);
 180         if (callback && callback->mQueue) {
 181             dispatch_async(callback->mQueue, ^{
 182                 callback->mHandler(nil, @ { @"value" : [NSNumber numberWithUnsignedChar:value] });
 183                 if (!callback->mKeepAlive) {
 184                     callback->Cancel();
 185                     delete callback;
 186                 }
 187             });
 188         }
 189     };
 190
 191 private:
 192     ResponseHandler mHandler;
 193     dispatch_queue_t mQueue;
 194     bool mKeepAlive;
 195 };
 196
 197 class CHIPInt8sAttributeCallbackBridge : public Callback::Callback<Int8sAttributeCallback> {
 198 public:
 199     CHIPInt8sAttributeCallbackBridge(ResponseHandler handler, dispatch_queue_t queue, bool keepAlive = false)
 200         : Callback::Callback<Int8sAttributeCallback>(CallbackFn, this)
 201         , mHandler(handler)
 202         , mQueue(queue)
 203         , mKeepAlive(keepAlive)
 204     {
 205     }
 206
 207     ~CHIPInt8sAttributeCallbackBridge() {};
 208
 209     static void CallbackFn(void * context, int8_t value)
 210     {
 211         CHIPInt8sAttributeCallbackBridge * callback = reinterpret_cast<CHIPInt8sAttributeCallbackBridge *>(context);
 212         if (callback && callback->mQueue) {
 213             dispatch_async(callback->mQueue, ^{
 214                 callback->mHandler(nil, @ { @"value" : [NSNumber numberWithChar:value] });
 215                 if (!callback->mKeepAlive) {
 216                     callback->Cancel();
 217                     delete callback;
 218                 }
 219             });
 220         }
 221     };
 222
 223 private:
 224     ResponseHandler mHandler;
 225     dispatch_queue_t mQueue;
 226     bool mKeepAlive;
 227 };
 228
 229 class CHIPInt16uAttributeCallbackBridge : public Callback::Callback<Int16uAttributeCallback> {
 230 public:
 231     CHIPInt16uAttributeCallbackBridge(ResponseHandler handler, dispatch_queue_t queue, bool keepAlive = false)
 232         : Callback::Callback<Int16uAttributeCallback>(CallbackFn, this)
 233         , mHandler(handler)
 234         , mQueue(queue)
 235         , mKeepAlive(keepAlive)
 236     {
 237     }
 238
 239     ~CHIPInt16uAttributeCallbackBridge() {};
 240
 241     static void CallbackFn(void * context, uint16_t value)
 242     {
 243         CHIPInt16uAttributeCallbackBridge * callback = reinterpret_cast<CHIPInt16uAttributeCallbackBridge *>(context);
 244         if (callback && callback->mQueue) {
 245             dispatch_async(callback->mQueue, ^{
 246                 callback->mHandler(nil, @ { @"value" : [NSNumber numberWithUnsignedShort:value] });
 247                 if (!callback->mKeepAlive) {
 248                     callback->Cancel();
 249                     delete callback;
 250                 }
 251             });
 252         }
 253     };
 254
 255 private:
 256     ResponseHandler mHandler;
 257     dispatch_queue_t mQueue;
 258     bool mKeepAlive;
 259 };
 260
 261 class CHIPInt32uAttributeCallbackBridge : public Callback::Callback<Int32uAttributeCallback> {
 262 public:
 263     CHIPInt32uAttributeCallbackBridge(ResponseHandler handler, dispatch_queue_t queue, bool keepAlive = false)
 264         : Callback::Callback<Int32uAttributeCallback>(CallbackFn, this)
 265         , mHandler(handler)
 266         , mQueue(queue)
 267         , mKeepAlive(keepAlive)
 268     {
 269     }
 270
 271     ~CHIPInt32uAttributeCallbackBridge() {};
 272
 273     static void CallbackFn(void * context, uint32_t value)
 274     {
 275         CHIPInt32uAttributeCallbackBridge * callback = reinterpret_cast<CHIPInt32uAttributeCallbackBridge *>(context);
 276         if (callback && callback->mQueue) {
 277             dispatch_async(callback->mQueue, ^{
 278                 callback->mHandler(nil, @ { @"value" : [NSNumber numberWithUnsignedLong:value] });
 279                 if (!callback->mKeepAlive) {
 280                     callback->Cancel();
 281                     delete callback;
 282                 }
 283             });
 284         }
 285     };
 286
 287 private:
 288     ResponseHandler mHandler;
 289     dispatch_queue_t mQueue;
 290     bool mKeepAlive;
 291 };
 292
 293 class CHIPInt64uAttributeCallbackBridge : public Callback::Callback<Int64uAttributeCallback> {
 294 public:
 295     CHIPInt64uAttributeCallbackBridge(ResponseHandler handler, dispatch_queue_t queue, bool keepAlive = false)
 296         : Callback::Callback<Int64uAttributeCallback>(CallbackFn, this)
 297         , mHandler(handler)
 298         , mQueue(queue)
 299         , mKeepAlive(keepAlive)
 300     {
 301     }
 302
 303     ~CHIPInt64uAttributeCallbackBridge() {};
 304
 305     static void CallbackFn(void * context, uint64_t value)
 306     {
 307         CHIPInt64uAttributeCallbackBridge * callback = reinterpret_cast<CHIPInt64uAttributeCallbackBridge *>(context);
 308         if (callback && callback->mQueue) {
 309             dispatch_async(callback->mQueue, ^{
 310                 callback->mHandler(nil, @ { @"value" : [NSNumber numberWithUnsignedLongLong:value] });
 311                 if (!callback->mKeepAlive) {
 312                     callback->Cancel();
 313                     delete callback;
 314                 }
 315             });
 316         }
 317     };
 318
 319 private:
 320     ResponseHandler mHandler;
 321     dispatch_queue_t mQueue;
 322     bool mKeepAlive;
 323 };
 324
 325 class CHIPInt16sAttributeCallbackBridge : public Callback::Callback<Int16sAttributeCallback> {
 326 public:
 327     CHIPInt16sAttributeCallbackBridge(ResponseHandler handler, dispatch_queue_t queue, bool keepAlive = false)
 328         : Callback::Callback<Int16sAttributeCallback>(CallbackFn, this)
 329         , mHandler(handler)
 330         , mQueue(queue)
 331         , mKeepAlive(keepAlive)
 332     {
 333     }
 334
 335     ~CHIPInt16sAttributeCallbackBridge() {};
 336
 337     static void CallbackFn(void * context, int16_t value)
 338     {
 339         CHIPInt16sAttributeCallbackBridge * callback = reinterpret_cast<CHIPInt16sAttributeCallbackBridge *>(context);
 340         if (callback && callback->mQueue) {
 341             dispatch_async(callback->mQueue, ^{
 342                 callback->mHandler(nil, @ { @"value" : [NSNumber numberWithShort:value] });
 343                 if (!callback->mKeepAlive) {
 344                     callback->Cancel();
 345                     delete callback;
 346                 }
 347             });
 348         }
 349     };
 350
 351 private:
 352     ResponseHandler mHandler;
 353     dispatch_queue_t mQueue;
 354     bool mKeepAlive;
 355 };
 356
 357 class CHIPDoorLockClusterLockDoorResponseCallbackBridge : public Callback::Callback<DoorLockClusterLockDoorResponseCallback> {
 358 public:
 359     CHIPDoorLockClusterLockDoorResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
 360         : Callback::Callback<DoorLockClusterLockDoorResponseCallback>(CallbackFn, this)
 361         , mHandler(handler)
 362         , mQueue(queue)
 363     {
 364     }
 365
 366     ~CHIPDoorLockClusterLockDoorResponseCallbackBridge() {};
 367
 368     static void CallbackFn(void * context)
 369     {
 370         CHIPDoorLockClusterLockDoorResponseCallbackBridge * callback
 371             = reinterpret_cast<CHIPDoorLockClusterLockDoorResponseCallbackBridge *>(context);
 372         if (callback && callback->mQueue) {
 373             dispatch_async(callback->mQueue, ^{
 374                 callback->mHandler(nil, @ {});
 375                 callback->Cancel();
 376                 delete callback;
 377             });
 378         }
 379     };
 380
 381 private:
 382     ResponseHandler mHandler;
 383     dispatch_queue_t mQueue;
 384 };
 385
 386 class CHIPDoorLockClusterUnlockDoorResponseCallbackBridge : public Callback::Callback<DoorLockClusterUnlockDoorResponseCallback> {
 387 public:
 388     CHIPDoorLockClusterUnlockDoorResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
 389         : Callback::Callback<DoorLockClusterUnlockDoorResponseCallback>(CallbackFn, this)
 390         , mHandler(handler)
 391         , mQueue(queue)
 392     {
 393     }
 394
 395     ~CHIPDoorLockClusterUnlockDoorResponseCallbackBridge() {};
 396
 397     static void CallbackFn(void * context)
 398     {
 399         CHIPDoorLockClusterUnlockDoorResponseCallbackBridge * callback
 400             = reinterpret_cast<CHIPDoorLockClusterUnlockDoorResponseCallbackBridge *>(context);
 401         if (callback && callback->mQueue) {
 402             dispatch_async(callback->mQueue, ^{
 403                 callback->mHandler(nil, @ {});
 404                 callback->Cancel();
 405                 delete callback;
 406             });
 407         }
 408     };
 409
 410 private:
 411     ResponseHandler mHandler;
 412     dispatch_queue_t mQueue;
 413 };
 414
 415 @interface CHIPCluster ()
 416 @property (readonly, nonatomic) dispatch_queue_t callbackQueue;
 417 - (Controller::ClusterBase *)getCluster;
 418 @end
 419
 420 @implementation CHIPCluster
 421 - (instancetype)initWithDevice:(CHIPDevice *)device endpoint:(EndpointId)endpoint queue:(dispatch_queue_t)queue
 422 {
 423     if (self = [super init]) {
 424         Controller::ClusterBase * cppCluster = [self getCluster];
 425         if (cppCluster == nullptr) {
 426             return nil;
 427         }
 428
 429         CHIP_ERROR err = cppCluster->Associate([device internalDevice], endpoint);
 430         if (err != CHIP_NO_ERROR) {
 431             return nil;
 432         }
 433
 434         _callbackQueue = queue;
 435     }
 436     return self;
 437 }
 438
 439 - (Controller::ClusterBase *)getCluster
 440 {
 441     return nullptr;
 442 }
 443 @end
 444
 445 @interface CHIPBarrierControl ()
 446 @property (readonly) Controller::BarrierControlCluster cppCluster;
 447 @end
 448
 449 @implementation CHIPBarrierControl
 450
 451 - (Controller::ClusterBase *)getCluster
 452 {
 453     return &_cppCluster;
 454 }
 455
 456 - (void)barrierControlGoToPercent:(uint8_t)percentOpen completionHandler:(ResponseHandler)completionHandler
 457 {
 458     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 459     if (!onSuccess) {
 460         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 461         return;
 462     }
 463
 464     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 465     if (!onFailure) {
 466         delete onSuccess;
 467         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 468         return;
 469     }
 470
 471     CHIP_ERROR err = self.cppCluster.BarrierControlGoToPercent(onSuccess->Cancel(), onFailure->Cancel(), percentOpen);
 472     if (err != CHIP_NO_ERROR) {
 473         delete onSuccess;
 474         delete onFailure;
 475         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 476     }
 477 }
 478 - (void)barrierControlStop:(ResponseHandler)completionHandler
 479 {
 480     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 481     if (!onSuccess) {
 482         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 483         return;
 484     }
 485
 486     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 487     if (!onFailure) {
 488         delete onSuccess;
 489         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 490         return;
 491     }
 492
 493     CHIP_ERROR err = self.cppCluster.BarrierControlStop(onSuccess->Cancel(), onFailure->Cancel());
 494     if (err != CHIP_NO_ERROR) {
 495         delete onSuccess;
 496         delete onFailure;
 497         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 498     }
 499 }
 500
 501 - (void)readAttributeBarrierMovingState:(ResponseHandler)completionHandler
 502 {
 503     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
 504     if (!onSuccess) {
 505         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 506         return;
 507     }
 508
 509     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 510     if (!onFailure) {
 511         delete onSuccess;
 512         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 513         return;
 514     }
 515
 516     CHIP_ERROR err = self.cppCluster.ReadAttributeBarrierMovingState(onSuccess->Cancel(), onFailure->Cancel());
 517     if (err != CHIP_NO_ERROR) {
 518         delete onSuccess;
 519         delete onFailure;
 520         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 521     }
 522 }
 523
 524 - (void)readAttributeBarrierSafetyStatus:(ResponseHandler)completionHandler
 525 {
 526     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
 527     if (!onSuccess) {
 528         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 529         return;
 530     }
 531
 532     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 533     if (!onFailure) {
 534         delete onSuccess;
 535         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 536         return;
 537     }
 538
 539     CHIP_ERROR err = self.cppCluster.ReadAttributeBarrierSafetyStatus(onSuccess->Cancel(), onFailure->Cancel());
 540     if (err != CHIP_NO_ERROR) {
 541         delete onSuccess;
 542         delete onFailure;
 543         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 544     }
 545 }
 546
 547 - (void)readAttributeBarrierCapabilities:(ResponseHandler)completionHandler
 548 {
 549     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
 550     if (!onSuccess) {
 551         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 552         return;
 553     }
 554
 555     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 556     if (!onFailure) {
 557         delete onSuccess;
 558         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 559         return;
 560     }
 561
 562     CHIP_ERROR err = self.cppCluster.ReadAttributeBarrierCapabilities(onSuccess->Cancel(), onFailure->Cancel());
 563     if (err != CHIP_NO_ERROR) {
 564         delete onSuccess;
 565         delete onFailure;
 566         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 567     }
 568 }
 569
 570 - (void)readAttributeBarrierPosition:(ResponseHandler)completionHandler
 571 {
 572     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
 573     if (!onSuccess) {
 574         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 575         return;
 576     }
 577
 578     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 579     if (!onFailure) {
 580         delete onSuccess;
 581         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 582         return;
 583     }
 584
 585     CHIP_ERROR err = self.cppCluster.ReadAttributeBarrierPosition(onSuccess->Cancel(), onFailure->Cancel());
 586     if (err != CHIP_NO_ERROR) {
 587         delete onSuccess;
 588         delete onFailure;
 589         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 590     }
 591 }
 592
 593 - (void)readAttributeClusterRevision:(ResponseHandler)completionHandler
 594 {
 595     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
 596     if (!onSuccess) {
 597         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 598         return;
 599     }
 600
 601     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 602     if (!onFailure) {
 603         delete onSuccess;
 604         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 605         return;
 606     }
 607
 608     CHIP_ERROR err = self.cppCluster.ReadAttributeClusterRevision(onSuccess->Cancel(), onFailure->Cancel());
 609     if (err != CHIP_NO_ERROR) {
 610         delete onSuccess;
 611         delete onFailure;
 612         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 613     }
 614 }
 615
 616 @end
 617
 618 @interface CHIPColorControl ()
 619 @property (readonly) Controller::ColorControlCluster cppCluster;
 620 @end
 621
 622 @implementation CHIPColorControl
 623
 624 - (Controller::ClusterBase *)getCluster
 625 {
 626     return &_cppCluster;
 627 }
 628
 629 - (void)moveColor:(int16_t)rateX
 630                 rateY:(int16_t)rateY
 631           optionsMask:(uint8_t)optionsMask
 632       optionsOverride:(uint8_t)optionsOverride
 633     completionHandler:(ResponseHandler)completionHandler
 634 {
 635     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 636     if (!onSuccess) {
 637         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 638         return;
 639     }
 640
 641     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 642     if (!onFailure) {
 643         delete onSuccess;
 644         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 645         return;
 646     }
 647
 648     CHIP_ERROR err
 649         = self.cppCluster.MoveColor(onSuccess->Cancel(), onFailure->Cancel(), rateX, rateY, optionsMask, optionsOverride);
 650     if (err != CHIP_NO_ERROR) {
 651         delete onSuccess;
 652         delete onFailure;
 653         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 654     }
 655 }
 656 - (void)moveColorTemperature:(uint8_t)moveMode
 657                         rate:(uint16_t)rate
 658      colorTemperatureMinimum:(uint16_t)colorTemperatureMinimum
 659      colorTemperatureMaximum:(uint16_t)colorTemperatureMaximum
 660                  optionsMask:(uint8_t)optionsMask
 661              optionsOverride:(uint8_t)optionsOverride
 662            completionHandler:(ResponseHandler)completionHandler
 663 {
 664     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 665     if (!onSuccess) {
 666         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 667         return;
 668     }
 669
 670     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 671     if (!onFailure) {
 672         delete onSuccess;
 673         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 674         return;
 675     }
 676
 677     CHIP_ERROR err = self.cppCluster.MoveColorTemperature(onSuccess->Cancel(), onFailure->Cancel(), moveMode, rate,
 678         colorTemperatureMinimum, colorTemperatureMaximum, optionsMask, optionsOverride);
 679     if (err != CHIP_NO_ERROR) {
 680         delete onSuccess;
 681         delete onFailure;
 682         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 683     }
 684 }
 685 - (void)moveHue:(uint8_t)moveMode
 686                  rate:(uint8_t)rate
 687           optionsMask:(uint8_t)optionsMask
 688       optionsOverride:(uint8_t)optionsOverride
 689     completionHandler:(ResponseHandler)completionHandler
 690 {
 691     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 692     if (!onSuccess) {
 693         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 694         return;
 695     }
 696
 697     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 698     if (!onFailure) {
 699         delete onSuccess;
 700         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 701         return;
 702     }
 703
 704     CHIP_ERROR err
 705         = self.cppCluster.MoveHue(onSuccess->Cancel(), onFailure->Cancel(), moveMode, rate, optionsMask, optionsOverride);
 706     if (err != CHIP_NO_ERROR) {
 707         delete onSuccess;
 708         delete onFailure;
 709         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 710     }
 711 }
 712 - (void)moveSaturation:(uint8_t)moveMode
 713                   rate:(uint8_t)rate
 714            optionsMask:(uint8_t)optionsMask
 715        optionsOverride:(uint8_t)optionsOverride
 716      completionHandler:(ResponseHandler)completionHandler
 717 {
 718     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 719     if (!onSuccess) {
 720         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 721         return;
 722     }
 723
 724     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 725     if (!onFailure) {
 726         delete onSuccess;
 727         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 728         return;
 729     }
 730
 731     CHIP_ERROR err
 732         = self.cppCluster.MoveSaturation(onSuccess->Cancel(), onFailure->Cancel(), moveMode, rate, optionsMask, optionsOverride);
 733     if (err != CHIP_NO_ERROR) {
 734         delete onSuccess;
 735         delete onFailure;
 736         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 737     }
 738 }
 739 - (void)moveToColor:(uint16_t)colorX
 740                colorY:(uint16_t)colorY
 741        transitionTime:(uint16_t)transitionTime
 742           optionsMask:(uint8_t)optionsMask
 743       optionsOverride:(uint8_t)optionsOverride
 744     completionHandler:(ResponseHandler)completionHandler
 745 {
 746     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 747     if (!onSuccess) {
 748         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 749         return;
 750     }
 751
 752     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 753     if (!onFailure) {
 754         delete onSuccess;
 755         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 756         return;
 757     }
 758
 759     CHIP_ERROR err = self.cppCluster.MoveToColor(
 760         onSuccess->Cancel(), onFailure->Cancel(), colorX, colorY, transitionTime, optionsMask, optionsOverride);
 761     if (err != CHIP_NO_ERROR) {
 762         delete onSuccess;
 763         delete onFailure;
 764         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 765     }
 766 }
 767 - (void)moveToColorTemperature:(uint16_t)colorTemperature
 768                 transitionTime:(uint16_t)transitionTime
 769                    optionsMask:(uint8_t)optionsMask
 770                optionsOverride:(uint8_t)optionsOverride
 771              completionHandler:(ResponseHandler)completionHandler
 772 {
 773     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 774     if (!onSuccess) {
 775         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 776         return;
 777     }
 778
 779     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 780     if (!onFailure) {
 781         delete onSuccess;
 782         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 783         return;
 784     }
 785
 786     CHIP_ERROR err = self.cppCluster.MoveToColorTemperature(
 787         onSuccess->Cancel(), onFailure->Cancel(), colorTemperature, transitionTime, optionsMask, optionsOverride);
 788     if (err != CHIP_NO_ERROR) {
 789         delete onSuccess;
 790         delete onFailure;
 791         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 792     }
 793 }
 794 - (void)moveToHue:(uint8_t)hue
 795             direction:(uint8_t)direction
 796        transitionTime:(uint16_t)transitionTime
 797           optionsMask:(uint8_t)optionsMask
 798       optionsOverride:(uint8_t)optionsOverride
 799     completionHandler:(ResponseHandler)completionHandler
 800 {
 801     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 802     if (!onSuccess) {
 803         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 804         return;
 805     }
 806
 807     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 808     if (!onFailure) {
 809         delete onSuccess;
 810         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 811         return;
 812     }
 813
 814     CHIP_ERROR err = self.cppCluster.MoveToHue(
 815         onSuccess->Cancel(), onFailure->Cancel(), hue, direction, transitionTime, optionsMask, optionsOverride);
 816     if (err != CHIP_NO_ERROR) {
 817         delete onSuccess;
 818         delete onFailure;
 819         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 820     }
 821 }
 822 - (void)moveToHueAndSaturation:(uint8_t)hue
 823                     saturation:(uint8_t)saturation
 824                 transitionTime:(uint16_t)transitionTime
 825                    optionsMask:(uint8_t)optionsMask
 826                optionsOverride:(uint8_t)optionsOverride
 827              completionHandler:(ResponseHandler)completionHandler
 828 {
 829     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 830     if (!onSuccess) {
 831         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 832         return;
 833     }
 834
 835     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 836     if (!onFailure) {
 837         delete onSuccess;
 838         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 839         return;
 840     }
 841
 842     CHIP_ERROR err = self.cppCluster.MoveToHueAndSaturation(
 843         onSuccess->Cancel(), onFailure->Cancel(), hue, saturation, transitionTime, optionsMask, optionsOverride);
 844     if (err != CHIP_NO_ERROR) {
 845         delete onSuccess;
 846         delete onFailure;
 847         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 848     }
 849 }
 850 - (void)moveToSaturation:(uint8_t)saturation
 851           transitionTime:(uint16_t)transitionTime
 852              optionsMask:(uint8_t)optionsMask
 853          optionsOverride:(uint8_t)optionsOverride
 854        completionHandler:(ResponseHandler)completionHandler
 855 {
 856     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 857     if (!onSuccess) {
 858         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 859         return;
 860     }
 861
 862     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 863     if (!onFailure) {
 864         delete onSuccess;
 865         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 866         return;
 867     }
 868
 869     CHIP_ERROR err = self.cppCluster.MoveToSaturation(
 870         onSuccess->Cancel(), onFailure->Cancel(), saturation, transitionTime, optionsMask, optionsOverride);
 871     if (err != CHIP_NO_ERROR) {
 872         delete onSuccess;
 873         delete onFailure;
 874         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 875     }
 876 }
 877 - (void)stepColor:(int16_t)stepX
 878                 stepY:(int16_t)stepY
 879        transitionTime:(uint16_t)transitionTime
 880           optionsMask:(uint8_t)optionsMask
 881       optionsOverride:(uint8_t)optionsOverride
 882     completionHandler:(ResponseHandler)completionHandler
 883 {
 884     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 885     if (!onSuccess) {
 886         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 887         return;
 888     }
 889
 890     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 891     if (!onFailure) {
 892         delete onSuccess;
 893         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 894         return;
 895     }
 896
 897     CHIP_ERROR err = self.cppCluster.StepColor(
 898         onSuccess->Cancel(), onFailure->Cancel(), stepX, stepY, transitionTime, optionsMask, optionsOverride);
 899     if (err != CHIP_NO_ERROR) {
 900         delete onSuccess;
 901         delete onFailure;
 902         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 903     }
 904 }
 905 - (void)stepColorTemperature:(uint8_t)stepMode
 906                     stepSize:(uint16_t)stepSize
 907               transitionTime:(uint16_t)transitionTime
 908      colorTemperatureMinimum:(uint16_t)colorTemperatureMinimum
 909      colorTemperatureMaximum:(uint16_t)colorTemperatureMaximum
 910                  optionsMask:(uint8_t)optionsMask
 911              optionsOverride:(uint8_t)optionsOverride
 912            completionHandler:(ResponseHandler)completionHandler
 913 {
 914     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 915     if (!onSuccess) {
 916         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 917         return;
 918     }
 919
 920     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 921     if (!onFailure) {
 922         delete onSuccess;
 923         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 924         return;
 925     }
 926
 927     CHIP_ERROR err = self.cppCluster.StepColorTemperature(onSuccess->Cancel(), onFailure->Cancel(), stepMode, stepSize,
 928         transitionTime, colorTemperatureMinimum, colorTemperatureMaximum, optionsMask, optionsOverride);
 929     if (err != CHIP_NO_ERROR) {
 930         delete onSuccess;
 931         delete onFailure;
 932         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 933     }
 934 }
 935 - (void)stepHue:(uint8_t)stepMode
 936              stepSize:(uint8_t)stepSize
 937        transitionTime:(uint8_t)transitionTime
 938           optionsMask:(uint8_t)optionsMask
 939       optionsOverride:(uint8_t)optionsOverride
 940     completionHandler:(ResponseHandler)completionHandler
 941 {
 942     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 943     if (!onSuccess) {
 944         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 945         return;
 946     }
 947
 948     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 949     if (!onFailure) {
 950         delete onSuccess;
 951         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 952         return;
 953     }
 954
 955     CHIP_ERROR err = self.cppCluster.StepHue(
 956         onSuccess->Cancel(), onFailure->Cancel(), stepMode, stepSize, transitionTime, optionsMask, optionsOverride);
 957     if (err != CHIP_NO_ERROR) {
 958         delete onSuccess;
 959         delete onFailure;
 960         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 961     }
 962 }
 963 - (void)stepSaturation:(uint8_t)stepMode
 964               stepSize:(uint8_t)stepSize
 965         transitionTime:(uint8_t)transitionTime
 966            optionsMask:(uint8_t)optionsMask
 967        optionsOverride:(uint8_t)optionsOverride
 968      completionHandler:(ResponseHandler)completionHandler
 969 {
 970     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 971     if (!onSuccess) {
 972         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 973         return;
 974     }
 975
 976     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 977     if (!onFailure) {
 978         delete onSuccess;
 979         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 980         return;
 981     }
 982
 983     CHIP_ERROR err = self.cppCluster.StepSaturation(
 984         onSuccess->Cancel(), onFailure->Cancel(), stepMode, stepSize, transitionTime, optionsMask, optionsOverride);
 985     if (err != CHIP_NO_ERROR) {
 986         delete onSuccess;
 987         delete onFailure;
 988         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 989     }
 990 }
 991 - (void)stopMoveStep:(uint8_t)optionsMask
 992       optionsOverride:(uint8_t)optionsOverride
 993     completionHandler:(ResponseHandler)completionHandler
 994 {
 995     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 996     if (!onSuccess) {
 997         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 998         return;
 999     }
1000
1001     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1002     if (!onFailure) {
1003         delete onSuccess;
1004         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1005         return;
1006     }
1007
1008     CHIP_ERROR err = self.cppCluster.StopMoveStep(onSuccess->Cancel(), onFailure->Cancel(), optionsMask, optionsOverride);
1009     if (err != CHIP_NO_ERROR) {
1010         delete onSuccess;
1011         delete onFailure;
1012         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1013     }
1014 }
1015
1016 - (void)readAttributeCurrentHue:(ResponseHandler)completionHandler
1017 {
1018     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1019     if (!onSuccess) {
1020         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1021         return;
1022     }
1023
1024     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1025     if (!onFailure) {
1026         delete onSuccess;
1027         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1028         return;
1029     }
1030
1031     CHIP_ERROR err = self.cppCluster.ReadAttributeCurrentHue(onSuccess->Cancel(), onFailure->Cancel());
1032     if (err != CHIP_NO_ERROR) {
1033         delete onSuccess;
1034         delete onFailure;
1035         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1036     }
1037 }
1038
1039 - (void)configureAttributeCurrentHue:(uint16_t)minInterval
1040                          maxInterval:(uint16_t)maxInterval
1041                               change:(uint8_t)change
1042                    completionHandler:(ResponseHandler)completionHandler
1043 {
1044     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1045     if (!onSuccess) {
1046         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1047         return;
1048     }
1049
1050     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1051     if (!onFailure) {
1052         delete onSuccess;
1053         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1054         return;
1055     }
1056
1057     CHIP_ERROR err
1058         = self.cppCluster.ConfigureAttributeCurrentHue(onSuccess->Cancel(), onFailure->Cancel(), minInterval, maxInterval, change);
1059     if (err != CHIP_NO_ERROR) {
1060         delete onSuccess;
1061         delete onFailure;
1062         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1063     }
1064 }
1065
1066 - (void)reportAttributeCurrentHue:(ResponseHandler)reportHandler
1067 {
1068     CHIPInt8uAttributeCallbackBridge * onReport = new CHIPInt8uAttributeCallbackBridge(reportHandler, [self callbackQueue], true);
1069     if (!onReport) {
1070         reportHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1071         return;
1072     }
1073
1074     CHIP_ERROR err = self.cppCluster.ReportAttributeCurrentHue(onReport->Cancel());
1075     if (err != CHIP_NO_ERROR) {
1076         delete onReport;
1077         reportHandler([CHIPError errorForCHIPErrorCode:err], nil);
1078     }
1079 }
1080
1081 - (void)readAttributeCurrentSaturation:(ResponseHandler)completionHandler
1082 {
1083     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1084     if (!onSuccess) {
1085         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1086         return;
1087     }
1088
1089     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1090     if (!onFailure) {
1091         delete onSuccess;
1092         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1093         return;
1094     }
1095
1096     CHIP_ERROR err = self.cppCluster.ReadAttributeCurrentSaturation(onSuccess->Cancel(), onFailure->Cancel());
1097     if (err != CHIP_NO_ERROR) {
1098         delete onSuccess;
1099         delete onFailure;
1100         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1101     }
1102 }
1103
1104 - (void)configureAttributeCurrentSaturation:(uint16_t)minInterval
1105                                 maxInterval:(uint16_t)maxInterval
1106                                      change:(uint8_t)change
1107                           completionHandler:(ResponseHandler)completionHandler
1108 {
1109     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1110     if (!onSuccess) {
1111         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1112         return;
1113     }
1114
1115     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1116     if (!onFailure) {
1117         delete onSuccess;
1118         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1119         return;
1120     }
1121
1122     CHIP_ERROR err = self.cppCluster.ConfigureAttributeCurrentSaturation(
1123         onSuccess->Cancel(), onFailure->Cancel(), minInterval, maxInterval, change);
1124     if (err != CHIP_NO_ERROR) {
1125         delete onSuccess;
1126         delete onFailure;
1127         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1128     }
1129 }
1130
1131 - (void)reportAttributeCurrentSaturation:(ResponseHandler)reportHandler
1132 {
1133     CHIPInt8uAttributeCallbackBridge * onReport = new CHIPInt8uAttributeCallbackBridge(reportHandler, [self callbackQueue], true);
1134     if (!onReport) {
1135         reportHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1136         return;
1137     }
1138
1139     CHIP_ERROR err = self.cppCluster.ReportAttributeCurrentSaturation(onReport->Cancel());
1140     if (err != CHIP_NO_ERROR) {
1141         delete onReport;
1142         reportHandler([CHIPError errorForCHIPErrorCode:err], nil);
1143     }
1144 }
1145
1146 - (void)readAttributeRemainingTime:(ResponseHandler)completionHandler
1147 {
1148     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1149     if (!onSuccess) {
1150         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1151         return;
1152     }
1153
1154     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1155     if (!onFailure) {
1156         delete onSuccess;
1157         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1158         return;
1159     }
1160
1161     CHIP_ERROR err = self.cppCluster.ReadAttributeRemainingTime(onSuccess->Cancel(), onFailure->Cancel());
1162     if (err != CHIP_NO_ERROR) {
1163         delete onSuccess;
1164         delete onFailure;
1165         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1166     }
1167 }
1168
1169 - (void)readAttributeCurrentX:(ResponseHandler)completionHandler
1170 {
1171     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1172     if (!onSuccess) {
1173         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1174         return;
1175     }
1176
1177     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1178     if (!onFailure) {
1179         delete onSuccess;
1180         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1181         return;
1182     }
1183
1184     CHIP_ERROR err = self.cppCluster.ReadAttributeCurrentX(onSuccess->Cancel(), onFailure->Cancel());
1185     if (err != CHIP_NO_ERROR) {
1186         delete onSuccess;
1187         delete onFailure;
1188         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1189     }
1190 }
1191
1192 - (void)configureAttributeCurrentX:(uint16_t)minInterval
1193                        maxInterval:(uint16_t)maxInterval
1194                             change:(uint16_t)change
1195                  completionHandler:(ResponseHandler)completionHandler
1196 {
1197     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1198     if (!onSuccess) {
1199         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1200         return;
1201     }
1202
1203     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1204     if (!onFailure) {
1205         delete onSuccess;
1206         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1207         return;
1208     }
1209
1210     CHIP_ERROR err
1211         = self.cppCluster.ConfigureAttributeCurrentX(onSuccess->Cancel(), onFailure->Cancel(), minInterval, maxInterval, change);
1212     if (err != CHIP_NO_ERROR) {
1213         delete onSuccess;
1214         delete onFailure;
1215         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1216     }
1217 }
1218
1219 - (void)reportAttributeCurrentX:(ResponseHandler)reportHandler
1220 {
1221     CHIPInt16uAttributeCallbackBridge * onReport = new CHIPInt16uAttributeCallbackBridge(reportHandler, [self callbackQueue], true);
1222     if (!onReport) {
1223         reportHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1224         return;
1225     }
1226
1227     CHIP_ERROR err = self.cppCluster.ReportAttributeCurrentX(onReport->Cancel());
1228     if (err != CHIP_NO_ERROR) {
1229         delete onReport;
1230         reportHandler([CHIPError errorForCHIPErrorCode:err], nil);
1231     }
1232 }
1233
1234 - (void)readAttributeCurrentY:(ResponseHandler)completionHandler
1235 {
1236     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1237     if (!onSuccess) {
1238         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1239         return;
1240     }
1241
1242     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1243     if (!onFailure) {
1244         delete onSuccess;
1245         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1246         return;
1247     }
1248
1249     CHIP_ERROR err = self.cppCluster.ReadAttributeCurrentY(onSuccess->Cancel(), onFailure->Cancel());
1250     if (err != CHIP_NO_ERROR) {
1251         delete onSuccess;
1252         delete onFailure;
1253         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1254     }
1255 }
1256
1257 - (void)configureAttributeCurrentY:(uint16_t)minInterval
1258                        maxInterval:(uint16_t)maxInterval
1259                             change:(uint16_t)change
1260                  completionHandler:(ResponseHandler)completionHandler
1261 {
1262     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1263     if (!onSuccess) {
1264         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1265         return;
1266     }
1267
1268     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1269     if (!onFailure) {
1270         delete onSuccess;
1271         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1272         return;
1273     }
1274
1275     CHIP_ERROR err
1276         = self.cppCluster.ConfigureAttributeCurrentY(onSuccess->Cancel(), onFailure->Cancel(), minInterval, maxInterval, change);
1277     if (err != CHIP_NO_ERROR) {
1278         delete onSuccess;
1279         delete onFailure;
1280         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1281     }
1282 }
1283
1284 - (void)reportAttributeCurrentY:(ResponseHandler)reportHandler
1285 {
1286     CHIPInt16uAttributeCallbackBridge * onReport = new CHIPInt16uAttributeCallbackBridge(reportHandler, [self callbackQueue], true);
1287     if (!onReport) {
1288         reportHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1289         return;
1290     }
1291
1292     CHIP_ERROR err = self.cppCluster.ReportAttributeCurrentY(onReport->Cancel());
1293     if (err != CHIP_NO_ERROR) {
1294         delete onReport;
1295         reportHandler([CHIPError errorForCHIPErrorCode:err], nil);
1296     }
1297 }
1298
1299 - (void)readAttributeDriftCompensation:(ResponseHandler)completionHandler
1300 {
1301     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1302     if (!onSuccess) {
1303         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1304         return;
1305     }
1306
1307     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1308     if (!onFailure) {
1309         delete onSuccess;
1310         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1311         return;
1312     }
1313
1314     CHIP_ERROR err = self.cppCluster.ReadAttributeDriftCompensation(onSuccess->Cancel(), onFailure->Cancel());
1315     if (err != CHIP_NO_ERROR) {
1316         delete onSuccess;
1317         delete onFailure;
1318         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1319     }
1320 }
1321
1322 - (void)readAttributeCompensationText:(ResponseHandler)completionHandler
1323 {
1324     CHIPStringAttributeCallbackBridge * onSuccess
1325         = new CHIPStringAttributeCallbackBridge(completionHandler, [self callbackQueue], false);
1326     if (!onSuccess) {
1327         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1328         return;
1329     }
1330
1331     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1332     if (!onFailure) {
1333         delete onSuccess;
1334         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1335         return;
1336     }
1337
1338     CHIP_ERROR err = self.cppCluster.ReadAttributeCompensationText(onSuccess->Cancel(), onFailure->Cancel());
1339     if (err != CHIP_NO_ERROR) {
1340         delete onSuccess;
1341         delete onFailure;
1342         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1343     }
1344 }
1345
1346 - (void)readAttributeColorTemperature:(ResponseHandler)completionHandler
1347 {
1348     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1349     if (!onSuccess) {
1350         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1351         return;
1352     }
1353
1354     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1355     if (!onFailure) {
1356         delete onSuccess;
1357         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1358         return;
1359     }
1360
1361     CHIP_ERROR err = self.cppCluster.ReadAttributeColorTemperature(onSuccess->Cancel(), onFailure->Cancel());
1362     if (err != CHIP_NO_ERROR) {
1363         delete onSuccess;
1364         delete onFailure;
1365         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1366     }
1367 }
1368
1369 - (void)configureAttributeColorTemperature:(uint16_t)minInterval
1370                                maxInterval:(uint16_t)maxInterval
1371                                     change:(uint16_t)change
1372                          completionHandler:(ResponseHandler)completionHandler
1373 {
1374     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1375     if (!onSuccess) {
1376         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1377         return;
1378     }
1379
1380     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1381     if (!onFailure) {
1382         delete onSuccess;
1383         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1384         return;
1385     }
1386
1387     CHIP_ERROR err = self.cppCluster.ConfigureAttributeColorTemperature(
1388         onSuccess->Cancel(), onFailure->Cancel(), minInterval, maxInterval, change);
1389     if (err != CHIP_NO_ERROR) {
1390         delete onSuccess;
1391         delete onFailure;
1392         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1393     }
1394 }
1395
1396 - (void)reportAttributeColorTemperature:(ResponseHandler)reportHandler
1397 {
1398     CHIPInt16uAttributeCallbackBridge * onReport = new CHIPInt16uAttributeCallbackBridge(reportHandler, [self callbackQueue], true);
1399     if (!onReport) {
1400         reportHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1401         return;
1402     }
1403
1404     CHIP_ERROR err = self.cppCluster.ReportAttributeColorTemperature(onReport->Cancel());
1405     if (err != CHIP_NO_ERROR) {
1406         delete onReport;
1407         reportHandler([CHIPError errorForCHIPErrorCode:err], nil);
1408     }
1409 }
1410
1411 - (void)readAttributeColorMode:(ResponseHandler)completionHandler
1412 {
1413     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1414     if (!onSuccess) {
1415         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1416         return;
1417     }
1418
1419     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1420     if (!onFailure) {
1421         delete onSuccess;
1422         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1423         return;
1424     }
1425
1426     CHIP_ERROR err = self.cppCluster.ReadAttributeColorMode(onSuccess->Cancel(), onFailure->Cancel());
1427     if (err != CHIP_NO_ERROR) {
1428         delete onSuccess;
1429         delete onFailure;
1430         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1431     }
1432 }
1433
1434 - (void)readAttributeColorControlOptions:(ResponseHandler)completionHandler
1435 {
1436     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1437     if (!onSuccess) {
1438         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1439         return;
1440     }
1441
1442     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1443     if (!onFailure) {
1444         delete onSuccess;
1445         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1446         return;
1447     }
1448
1449     CHIP_ERROR err = self.cppCluster.ReadAttributeColorControlOptions(onSuccess->Cancel(), onFailure->Cancel());
1450     if (err != CHIP_NO_ERROR) {
1451         delete onSuccess;
1452         delete onFailure;
1453         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1454     }
1455 }
1456
1457 - (void)writeAttributeColorControlOptions:(uint8_t)value completionHandler:(ResponseHandler)completionHandler
1458 {
1459     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1460     if (!onSuccess) {
1461         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1462         return;
1463     }
1464
1465     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1466     if (!onFailure) {
1467         delete onSuccess;
1468         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1469         return;
1470     }
1471
1472     CHIP_ERROR err = self.cppCluster.WriteAttributeColorControlOptions(onSuccess->Cancel(), onFailure->Cancel(), value);
1473     if (err != CHIP_NO_ERROR) {
1474         delete onSuccess;
1475         delete onFailure;
1476         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1477     }
1478 }
1479
1480 - (void)readAttributeNumberOfPrimaries:(ResponseHandler)completionHandler
1481 {
1482     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1483     if (!onSuccess) {
1484         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1485         return;
1486     }
1487
1488     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1489     if (!onFailure) {
1490         delete onSuccess;
1491         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1492         return;
1493     }
1494
1495     CHIP_ERROR err = self.cppCluster.ReadAttributeNumberOfPrimaries(onSuccess->Cancel(), onFailure->Cancel());
1496     if (err != CHIP_NO_ERROR) {
1497         delete onSuccess;
1498         delete onFailure;
1499         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1500     }
1501 }
1502
1503 - (void)readAttributePrimary1X:(ResponseHandler)completionHandler
1504 {
1505     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1506     if (!onSuccess) {
1507         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1508         return;
1509     }
1510
1511     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1512     if (!onFailure) {
1513         delete onSuccess;
1514         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1515         return;
1516     }
1517
1518     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary1X(onSuccess->Cancel(), onFailure->Cancel());
1519     if (err != CHIP_NO_ERROR) {
1520         delete onSuccess;
1521         delete onFailure;
1522         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1523     }
1524 }
1525
1526 - (void)readAttributePrimary1Y:(ResponseHandler)completionHandler
1527 {
1528     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1529     if (!onSuccess) {
1530         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1531         return;
1532     }
1533
1534     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1535     if (!onFailure) {
1536         delete onSuccess;
1537         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1538         return;
1539     }
1540
1541     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary1Y(onSuccess->Cancel(), onFailure->Cancel());
1542     if (err != CHIP_NO_ERROR) {
1543         delete onSuccess;
1544         delete onFailure;
1545         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1546     }
1547 }
1548
1549 - (void)readAttributePrimary1Intensity:(ResponseHandler)completionHandler
1550 {
1551     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1552     if (!onSuccess) {
1553         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1554         return;
1555     }
1556
1557     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1558     if (!onFailure) {
1559         delete onSuccess;
1560         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1561         return;
1562     }
1563
1564     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary1Intensity(onSuccess->Cancel(), onFailure->Cancel());
1565     if (err != CHIP_NO_ERROR) {
1566         delete onSuccess;
1567         delete onFailure;
1568         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1569     }
1570 }
1571
1572 - (void)readAttributePrimary2X:(ResponseHandler)completionHandler
1573 {
1574     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1575     if (!onSuccess) {
1576         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1577         return;
1578     }
1579
1580     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1581     if (!onFailure) {
1582         delete onSuccess;
1583         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1584         return;
1585     }
1586
1587     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary2X(onSuccess->Cancel(), onFailure->Cancel());
1588     if (err != CHIP_NO_ERROR) {
1589         delete onSuccess;
1590         delete onFailure;
1591         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1592     }
1593 }
1594
1595 - (void)readAttributePrimary2Y:(ResponseHandler)completionHandler
1596 {
1597     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1598     if (!onSuccess) {
1599         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1600         return;
1601     }
1602
1603     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1604     if (!onFailure) {
1605         delete onSuccess;
1606         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1607         return;
1608     }
1609
1610     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary2Y(onSuccess->Cancel(), onFailure->Cancel());
1611     if (err != CHIP_NO_ERROR) {
1612         delete onSuccess;
1613         delete onFailure;
1614         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1615     }
1616 }
1617
1618 - (void)readAttributePrimary2Intensity:(ResponseHandler)completionHandler
1619 {
1620     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1621     if (!onSuccess) {
1622         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1623         return;
1624     }
1625
1626     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1627     if (!onFailure) {
1628         delete onSuccess;
1629         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1630         return;
1631     }
1632
1633     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary2Intensity(onSuccess->Cancel(), onFailure->Cancel());
1634     if (err != CHIP_NO_ERROR) {
1635         delete onSuccess;
1636         delete onFailure;
1637         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1638     }
1639 }
1640
1641 - (void)readAttributePrimary3X:(ResponseHandler)completionHandler
1642 {
1643     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1644     if (!onSuccess) {
1645         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1646         return;
1647     }
1648
1649     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1650     if (!onFailure) {
1651         delete onSuccess;
1652         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1653         return;
1654     }
1655
1656     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary3X(onSuccess->Cancel(), onFailure->Cancel());
1657     if (err != CHIP_NO_ERROR) {
1658         delete onSuccess;
1659         delete onFailure;
1660         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1661     }
1662 }
1663
1664 - (void)readAttributePrimary3Y:(ResponseHandler)completionHandler
1665 {
1666     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1667     if (!onSuccess) {
1668         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1669         return;
1670     }
1671
1672     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1673     if (!onFailure) {
1674         delete onSuccess;
1675         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1676         return;
1677     }
1678
1679     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary3Y(onSuccess->Cancel(), onFailure->Cancel());
1680     if (err != CHIP_NO_ERROR) {
1681         delete onSuccess;
1682         delete onFailure;
1683         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1684     }
1685 }
1686
1687 - (void)readAttributePrimary3Intensity:(ResponseHandler)completionHandler
1688 {
1689     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1690     if (!onSuccess) {
1691         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1692         return;
1693     }
1694
1695     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1696     if (!onFailure) {
1697         delete onSuccess;
1698         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1699         return;
1700     }
1701
1702     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary3Intensity(onSuccess->Cancel(), onFailure->Cancel());
1703     if (err != CHIP_NO_ERROR) {
1704         delete onSuccess;
1705         delete onFailure;
1706         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1707     }
1708 }
1709
1710 - (void)readAttributePrimary4X:(ResponseHandler)completionHandler
1711 {
1712     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1713     if (!onSuccess) {
1714         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1715         return;
1716     }
1717
1718     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1719     if (!onFailure) {
1720         delete onSuccess;
1721         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1722         return;
1723     }
1724
1725     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary4X(onSuccess->Cancel(), onFailure->Cancel());
1726     if (err != CHIP_NO_ERROR) {
1727         delete onSuccess;
1728         delete onFailure;
1729         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1730     }
1731 }
1732
1733 - (void)readAttributePrimary4Y:(ResponseHandler)completionHandler
1734 {
1735     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1736     if (!onSuccess) {
1737         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1738         return;
1739     }
1740
1741     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1742     if (!onFailure) {
1743         delete onSuccess;
1744         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1745         return;
1746     }
1747
1748     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary4Y(onSuccess->Cancel(), onFailure->Cancel());
1749     if (err != CHIP_NO_ERROR) {
1750         delete onSuccess;
1751         delete onFailure;
1752         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1753     }
1754 }
1755
1756 - (void)readAttributePrimary4Intensity:(ResponseHandler)completionHandler
1757 {
1758     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1759     if (!onSuccess) {
1760         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1761         return;
1762     }
1763
1764     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1765     if (!onFailure) {
1766         delete onSuccess;
1767         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1768         return;
1769     }
1770
1771     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary4Intensity(onSuccess->Cancel(), onFailure->Cancel());
1772     if (err != CHIP_NO_ERROR) {
1773         delete onSuccess;
1774         delete onFailure;
1775         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1776     }
1777 }
1778
1779 - (void)readAttributePrimary5X:(ResponseHandler)completionHandler
1780 {
1781     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1782     if (!onSuccess) {
1783         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1784         return;
1785     }
1786
1787     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1788     if (!onFailure) {
1789         delete onSuccess;
1790         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1791         return;
1792     }
1793
1794     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary5X(onSuccess->Cancel(), onFailure->Cancel());
1795     if (err != CHIP_NO_ERROR) {
1796         delete onSuccess;
1797         delete onFailure;
1798         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1799     }
1800 }
1801
1802 - (void)readAttributePrimary5Y:(ResponseHandler)completionHandler
1803 {
1804     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1805     if (!onSuccess) {
1806         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1807         return;
1808     }
1809
1810     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1811     if (!onFailure) {
1812         delete onSuccess;
1813         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1814         return;
1815     }
1816
1817     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary5Y(onSuccess->Cancel(), onFailure->Cancel());
1818     if (err != CHIP_NO_ERROR) {
1819         delete onSuccess;
1820         delete onFailure;
1821         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1822     }
1823 }
1824
1825 - (void)readAttributePrimary5Intensity:(ResponseHandler)completionHandler
1826 {
1827     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1828     if (!onSuccess) {
1829         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1830         return;
1831     }
1832
1833     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1834     if (!onFailure) {
1835         delete onSuccess;
1836         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1837         return;
1838     }
1839
1840     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary5Intensity(onSuccess->Cancel(), onFailure->Cancel());
1841     if (err != CHIP_NO_ERROR) {
1842         delete onSuccess;
1843         delete onFailure;
1844         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1845     }
1846 }
1847
1848 - (void)readAttributePrimary6X:(ResponseHandler)completionHandler
1849 {
1850     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1851     if (!onSuccess) {
1852         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1853         return;
1854     }
1855
1856     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1857     if (!onFailure) {
1858         delete onSuccess;
1859         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1860         return;
1861     }
1862
1863     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary6X(onSuccess->Cancel(), onFailure->Cancel());
1864     if (err != CHIP_NO_ERROR) {
1865         delete onSuccess;
1866         delete onFailure;
1867         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1868     }
1869 }
1870
1871 - (void)readAttributePrimary6Y:(ResponseHandler)completionHandler
1872 {
1873     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1874     if (!onSuccess) {
1875         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1876         return;
1877     }
1878
1879     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1880     if (!onFailure) {
1881         delete onSuccess;
1882         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1883         return;
1884     }
1885
1886     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary6Y(onSuccess->Cancel(), onFailure->Cancel());
1887     if (err != CHIP_NO_ERROR) {
1888         delete onSuccess;
1889         delete onFailure;
1890         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1891     }
1892 }
1893
1894 - (void)readAttributePrimary6Intensity:(ResponseHandler)completionHandler
1895 {
1896     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1897     if (!onSuccess) {
1898         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1899         return;
1900     }
1901
1902     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1903     if (!onFailure) {
1904         delete onSuccess;
1905         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1906         return;
1907     }
1908
1909     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary6Intensity(onSuccess->Cancel(), onFailure->Cancel());
1910     if (err != CHIP_NO_ERROR) {
1911         delete onSuccess;
1912         delete onFailure;
1913         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1914     }
1915 }
1916
1917 - (void)readAttributeWhitePointX:(ResponseHandler)completionHandler
1918 {
1919     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1920     if (!onSuccess) {
1921         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1922         return;
1923     }
1924
1925     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1926     if (!onFailure) {
1927         delete onSuccess;
1928         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1929         return;
1930     }
1931
1932     CHIP_ERROR err = self.cppCluster.ReadAttributeWhitePointX(onSuccess->Cancel(), onFailure->Cancel());
1933     if (err != CHIP_NO_ERROR) {
1934         delete onSuccess;
1935         delete onFailure;
1936         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1937     }
1938 }
1939
1940 - (void)writeAttributeWhitePointX:(uint16_t)value completionHandler:(ResponseHandler)completionHandler
1941 {
1942     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1943     if (!onSuccess) {
1944         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1945         return;
1946     }
1947
1948     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1949     if (!onFailure) {
1950         delete onSuccess;
1951         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1952         return;
1953     }
1954
1955     CHIP_ERROR err = self.cppCluster.WriteAttributeWhitePointX(onSuccess->Cancel(), onFailure->Cancel(), value);
1956     if (err != CHIP_NO_ERROR) {
1957         delete onSuccess;
1958         delete onFailure;
1959         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1960     }
1961 }
1962
1963 - (void)readAttributeWhitePointY:(ResponseHandler)completionHandler
1964 {
1965     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1966     if (!onSuccess) {
1967         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1968         return;
1969     }
1970
1971     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1972     if (!onFailure) {
1973         delete onSuccess;
1974         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1975         return;
1976     }
1977
1978     CHIP_ERROR err = self.cppCluster.ReadAttributeWhitePointY(onSuccess->Cancel(), onFailure->Cancel());
1979     if (err != CHIP_NO_ERROR) {
1980         delete onSuccess;
1981         delete onFailure;
1982         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1983     }
1984 }
1985
1986 - (void)writeAttributeWhitePointY:(uint16_t)value completionHandler:(ResponseHandler)completionHandler
1987 {
1988     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1989     if (!onSuccess) {
1990         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1991         return;
1992     }
1993
1994     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1995     if (!onFailure) {
1996         delete onSuccess;
1997         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1998         return;
1999     }
2000
2001     CHIP_ERROR err = self.cppCluster.WriteAttributeWhitePointY(onSuccess->Cancel(), onFailure->Cancel(), value);
2002     if (err != CHIP_NO_ERROR) {
2003         delete onSuccess;
2004         delete onFailure;
2005         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2006     }
2007 }
2008
2009 - (void)readAttributeColorPointRX:(ResponseHandler)completionHandler
2010 {
2011     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2012     if (!onSuccess) {
2013         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2014         return;
2015     }
2016
2017     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2018     if (!onFailure) {
2019         delete onSuccess;
2020         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2021         return;
2022     }
2023
2024     CHIP_ERROR err = self.cppCluster.ReadAttributeColorPointRX(onSuccess->Cancel(), onFailure->Cancel());
2025     if (err != CHIP_NO_ERROR) {
2026         delete onSuccess;
2027         delete onFailure;
2028         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2029     }
2030 }
2031
2032 - (void)writeAttributeColorPointRX:(uint16_t)value completionHandler:(ResponseHandler)completionHandler
2033 {
2034     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2035     if (!onSuccess) {
2036         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2037         return;
2038     }
2039
2040     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2041     if (!onFailure) {
2042         delete onSuccess;
2043         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2044         return;
2045     }
2046
2047     CHIP_ERROR err = self.cppCluster.WriteAttributeColorPointRX(onSuccess->Cancel(), onFailure->Cancel(), value);
2048     if (err != CHIP_NO_ERROR) {
2049         delete onSuccess;
2050         delete onFailure;
2051         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2052     }
2053 }
2054
2055 - (void)readAttributeColorPointRY:(ResponseHandler)completionHandler
2056 {
2057     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2058     if (!onSuccess) {
2059         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2060         return;
2061     }
2062
2063     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2064     if (!onFailure) {
2065         delete onSuccess;
2066         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2067         return;
2068     }
2069
2070     CHIP_ERROR err = self.cppCluster.ReadAttributeColorPointRY(onSuccess->Cancel(), onFailure->Cancel());
2071     if (err != CHIP_NO_ERROR) {
2072         delete onSuccess;
2073         delete onFailure;
2074         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2075     }
2076 }
2077
2078 - (void)writeAttributeColorPointRY:(uint16_t)value completionHandler:(ResponseHandler)completionHandler
2079 {
2080     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2081     if (!onSuccess) {
2082         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2083         return;
2084     }
2085
2086     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2087     if (!onFailure) {
2088         delete onSuccess;
2089         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2090         return;
2091     }
2092
2093     CHIP_ERROR err = self.cppCluster.WriteAttributeColorPointRY(onSuccess->Cancel(), onFailure->Cancel(), value);
2094     if (err != CHIP_NO_ERROR) {
2095         delete onSuccess;
2096         delete onFailure;
2097         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2098     }
2099 }
2100
2101 - (void)readAttributeColorPointRIntensity:(ResponseHandler)completionHandler
2102 {
2103     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2104     if (!onSuccess) {
2105         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2106         return;
2107     }
2108
2109     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2110     if (!onFailure) {
2111         delete onSuccess;
2112         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2113         return;
2114     }
2115
2116     CHIP_ERROR err = self.cppCluster.ReadAttributeColorPointRIntensity(onSuccess->Cancel(), onFailure->Cancel());
2117     if (err != CHIP_NO_ERROR) {
2118         delete onSuccess;
2119         delete onFailure;
2120         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2121     }
2122 }
2123
2124 - (void)writeAttributeColorPointRIntensity:(uint8_t)value completionHandler:(ResponseHandler)completionHandler
2125 {
2126     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2127     if (!onSuccess) {
2128         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2129         return;
2130     }
2131
2132     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2133     if (!onFailure) {
2134         delete onSuccess;
2135         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2136         return;
2137     }
2138
2139     CHIP_ERROR err = self.cppCluster.WriteAttributeColorPointRIntensity(onSuccess->Cancel(), onFailure->Cancel(), value);
2140     if (err != CHIP_NO_ERROR) {
2141         delete onSuccess;
2142         delete onFailure;
2143         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2144     }
2145 }
2146
2147 - (void)readAttributeColorPointGX:(ResponseHandler)completionHandler
2148 {
2149     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2150     if (!onSuccess) {
2151         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2152         return;
2153     }
2154
2155     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2156     if (!onFailure) {
2157         delete onSuccess;
2158         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2159         return;
2160     }
2161
2162     CHIP_ERROR err = self.cppCluster.ReadAttributeColorPointGX(onSuccess->Cancel(), onFailure->Cancel());
2163     if (err != CHIP_NO_ERROR) {
2164         delete onSuccess;
2165         delete onFailure;
2166         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2167     }
2168 }
2169
2170 - (void)writeAttributeColorPointGX:(uint16_t)value completionHandler:(ResponseHandler)completionHandler
2171 {
2172     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2173     if (!onSuccess) {
2174         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2175         return;
2176     }
2177
2178     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2179     if (!onFailure) {
2180         delete onSuccess;
2181         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2182         return;
2183     }
2184
2185     CHIP_ERROR err = self.cppCluster.WriteAttributeColorPointGX(onSuccess->Cancel(), onFailure->Cancel(), value);
2186     if (err != CHIP_NO_ERROR) {
2187         delete onSuccess;
2188         delete onFailure;
2189         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2190     }
2191 }
2192
2193 - (void)readAttributeColorPointGY:(ResponseHandler)completionHandler
2194 {
2195     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2196     if (!onSuccess) {
2197         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2198         return;
2199     }
2200
2201     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2202     if (!onFailure) {
2203         delete onSuccess;
2204         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2205         return;
2206     }
2207
2208     CHIP_ERROR err = self.cppCluster.ReadAttributeColorPointGY(onSuccess->Cancel(), onFailure->Cancel());
2209     if (err != CHIP_NO_ERROR) {
2210         delete onSuccess;
2211         delete onFailure;
2212         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2213     }
2214 }
2215
2216 - (void)writeAttributeColorPointGY:(uint16_t)value completionHandler:(ResponseHandler)completionHandler
2217 {
2218     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2219     if (!onSuccess) {
2220         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2221         return;
2222     }
2223
2224     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2225     if (!onFailure) {
2226         delete onSuccess;
2227         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2228         return;
2229     }
2230
2231     CHIP_ERROR err = self.cppCluster.WriteAttributeColorPointGY(onSuccess->Cancel(), onFailure->Cancel(), value);
2232     if (err != CHIP_NO_ERROR) {
2233         delete onSuccess;
2234         delete onFailure;
2235         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2236     }
2237 }
2238
2239 - (void)readAttributeColorPointGIntensity:(ResponseHandler)completionHandler
2240 {
2241     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2242     if (!onSuccess) {
2243         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2244         return;
2245     }
2246
2247     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2248     if (!onFailure) {
2249         delete onSuccess;
2250         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2251         return;
2252     }
2253
2254     CHIP_ERROR err = self.cppCluster.ReadAttributeColorPointGIntensity(onSuccess->Cancel(), onFailure->Cancel());
2255     if (err != CHIP_NO_ERROR) {
2256         delete onSuccess;
2257         delete onFailure;
2258         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2259     }
2260 }
2261
2262 - (void)writeAttributeColorPointGIntensity:(uint8_t)value completionHandler:(ResponseHandler)completionHandler
2263 {
2264     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2265     if (!onSuccess) {
2266         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2267         return;
2268     }
2269
2270     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2271     if (!onFailure) {
2272         delete onSuccess;
2273         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2274         return;
2275     }
2276
2277     CHIP_ERROR err = self.cppCluster.WriteAttributeColorPointGIntensity(onSuccess->Cancel(), onFailure->Cancel(), value);
2278     if (err != CHIP_NO_ERROR) {
2279         delete onSuccess;
2280         delete onFailure;
2281         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2282     }
2283 }
2284
2285 - (void)readAttributeColorPointBX:(ResponseHandler)completionHandler
2286 {
2287     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2288     if (!onSuccess) {
2289         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2290         return;
2291     }
2292
2293     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2294     if (!onFailure) {
2295         delete onSuccess;
2296         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2297         return;
2298     }
2299
2300     CHIP_ERROR err = self.cppCluster.ReadAttributeColorPointBX(onSuccess->Cancel(), onFailure->Cancel());
2301     if (err != CHIP_NO_ERROR) {
2302         delete onSuccess;
2303         delete onFailure;
2304         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2305     }
2306 }
2307
2308 - (void)writeAttributeColorPointBX:(uint16_t)value completionHandler:(ResponseHandler)completionHandler
2309 {
2310     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2311     if (!onSuccess) {
2312         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2313         return;
2314     }
2315
2316     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2317     if (!onFailure) {
2318         delete onSuccess;
2319         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2320         return;
2321     }
2322
2323     CHIP_ERROR err = self.cppCluster.WriteAttributeColorPointBX(onSuccess->Cancel(), onFailure->Cancel(), value);
2324     if (err != CHIP_NO_ERROR) {
2325         delete onSuccess;
2326         delete onFailure;
2327         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2328     }
2329 }
2330
2331 - (void)readAttributeColorPointBY:(ResponseHandler)completionHandler
2332 {
2333     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2334     if (!onSuccess) {
2335         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2336         return;
2337     }
2338
2339     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2340     if (!onFailure) {
2341         delete onSuccess;
2342         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2343         return;
2344     }
2345
2346     CHIP_ERROR err = self.cppCluster.ReadAttributeColorPointBY(onSuccess->Cancel(), onFailure->Cancel());
2347     if (err != CHIP_NO_ERROR) {
2348         delete onSuccess;
2349         delete onFailure;
2350         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2351     }
2352 }
2353
2354 - (void)writeAttributeColorPointBY:(uint16_t)value completionHandler:(ResponseHandler)completionHandler
2355 {
2356     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2357     if (!onSuccess) {
2358         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2359         return;
2360     }
2361
2362     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2363     if (!onFailure) {
2364         delete onSuccess;
2365         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2366         return;
2367     }
2368
2369     CHIP_ERROR err = self.cppCluster.WriteAttributeColorPointBY(onSuccess->Cancel(), onFailure->Cancel(), value);
2370     if (err != CHIP_NO_ERROR) {
2371         delete onSuccess;
2372         delete onFailure;
2373         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2374     }
2375 }
2376
2377 - (void)readAttributeColorPointBIntensity:(ResponseHandler)completionHandler
2378 {
2379     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2380     if (!onSuccess) {
2381         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2382         return;
2383     }
2384
2385     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2386     if (!onFailure) {
2387         delete onSuccess;
2388         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2389         return;
2390     }
2391
2392     CHIP_ERROR err = self.cppCluster.ReadAttributeColorPointBIntensity(onSuccess->Cancel(), onFailure->Cancel());
2393     if (err != CHIP_NO_ERROR) {
2394         delete onSuccess;
2395         delete onFailure;
2396         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2397     }
2398 }
2399
2400 - (void)writeAttributeColorPointBIntensity:(uint8_t)value completionHandler:(ResponseHandler)completionHandler
2401 {
2402     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2403     if (!onSuccess) {
2404         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2405         return;
2406     }
2407
2408     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2409     if (!onFailure) {
2410         delete onSuccess;
2411         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2412         return;
2413     }
2414
2415     CHIP_ERROR err = self.cppCluster.WriteAttributeColorPointBIntensity(onSuccess->Cancel(), onFailure->Cancel(), value);
2416     if (err != CHIP_NO_ERROR) {
2417         delete onSuccess;
2418         delete onFailure;
2419         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2420     }
2421 }
2422
2423 - (void)readAttributeEnhancedCurrentHue:(ResponseHandler)completionHandler
2424 {
2425     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2426     if (!onSuccess) {
2427         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2428         return;
2429     }
2430
2431     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2432     if (!onFailure) {
2433         delete onSuccess;
2434         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2435         return;
2436     }
2437
2438     CHIP_ERROR err = self.cppCluster.ReadAttributeEnhancedCurrentHue(onSuccess->Cancel(), onFailure->Cancel());
2439     if (err != CHIP_NO_ERROR) {
2440         delete onSuccess;
2441         delete onFailure;
2442         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2443     }
2444 }
2445
2446 - (void)readAttributeEnhancedColorMode:(ResponseHandler)completionHandler
2447 {
2448     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2449     if (!onSuccess) {
2450         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2451         return;
2452     }
2453
2454     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2455     if (!onFailure) {
2456         delete onSuccess;
2457         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2458         return;
2459     }
2460
2461     CHIP_ERROR err = self.cppCluster.ReadAttributeEnhancedColorMode(onSuccess->Cancel(), onFailure->Cancel());
2462     if (err != CHIP_NO_ERROR) {
2463         delete onSuccess;
2464         delete onFailure;
2465         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2466     }
2467 }
2468
2469 - (void)readAttributeColorLoopActive:(ResponseHandler)completionHandler
2470 {
2471     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2472     if (!onSuccess) {
2473         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2474         return;
2475     }
2476
2477     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2478     if (!onFailure) {
2479         delete onSuccess;
2480         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2481         return;
2482     }
2483
2484     CHIP_ERROR err = self.cppCluster.ReadAttributeColorLoopActive(onSuccess->Cancel(), onFailure->Cancel());
2485     if (err != CHIP_NO_ERROR) {
2486         delete onSuccess;
2487         delete onFailure;
2488         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2489     }
2490 }
2491
2492 - (void)readAttributeColorLoopDirection:(ResponseHandler)completionHandler
2493 {
2494     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2495     if (!onSuccess) {
2496         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2497         return;
2498     }
2499
2500     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2501     if (!onFailure) {
2502         delete onSuccess;
2503         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2504         return;
2505     }
2506
2507     CHIP_ERROR err = self.cppCluster.ReadAttributeColorLoopDirection(onSuccess->Cancel(), onFailure->Cancel());
2508     if (err != CHIP_NO_ERROR) {
2509         delete onSuccess;
2510         delete onFailure;
2511         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2512     }
2513 }
2514
2515 - (void)readAttributeColorLoopTime:(ResponseHandler)completionHandler
2516 {
2517     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2518     if (!onSuccess) {
2519         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2520         return;
2521     }
2522
2523     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2524     if (!onFailure) {
2525         delete onSuccess;
2526         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2527         return;
2528     }
2529
2530     CHIP_ERROR err = self.cppCluster.ReadAttributeColorLoopTime(onSuccess->Cancel(), onFailure->Cancel());
2531     if (err != CHIP_NO_ERROR) {
2532         delete onSuccess;
2533         delete onFailure;
2534         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2535     }
2536 }
2537
2538 - (void)readAttributeColorCapabilities:(ResponseHandler)completionHandler
2539 {
2540     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2541     if (!onSuccess) {
2542         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2543         return;
2544     }
2545
2546     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2547     if (!onFailure) {
2548         delete onSuccess;
2549         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2550         return;
2551     }
2552
2553     CHIP_ERROR err = self.cppCluster.ReadAttributeColorCapabilities(onSuccess->Cancel(), onFailure->Cancel());
2554     if (err != CHIP_NO_ERROR) {
2555         delete onSuccess;
2556         delete onFailure;
2557         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2558     }
2559 }
2560
2561 - (void)readAttributeColorTempPhysicalMin:(ResponseHandler)completionHandler
2562 {
2563     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2564     if (!onSuccess) {
2565         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2566         return;
2567     }
2568
2569     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2570     if (!onFailure) {
2571         delete onSuccess;
2572         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2573         return;
2574     }
2575
2576     CHIP_ERROR err = self.cppCluster.ReadAttributeColorTempPhysicalMin(onSuccess->Cancel(), onFailure->Cancel());
2577     if (err != CHIP_NO_ERROR) {
2578         delete onSuccess;
2579         delete onFailure;
2580         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2581     }
2582 }
2583
2584 - (void)readAttributeColorTempPhysicalMax:(ResponseHandler)completionHandler
2585 {
2586     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2587     if (!onSuccess) {
2588         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2589         return;
2590     }
2591
2592     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2593     if (!onFailure) {
2594         delete onSuccess;
2595         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2596         return;
2597     }
2598
2599     CHIP_ERROR err = self.cppCluster.ReadAttributeColorTempPhysicalMax(onSuccess->Cancel(), onFailure->Cancel());
2600     if (err != CHIP_NO_ERROR) {
2601         delete onSuccess;
2602         delete onFailure;
2603         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2604     }
2605 }
2606
2607 - (void)readAttributeCoupleColorTempToLevelMinMireds:(ResponseHandler)completionHandler
2608 {
2609     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2610     if (!onSuccess) {
2611         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2612         return;
2613     }
2614
2615     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2616     if (!onFailure) {
2617         delete onSuccess;
2618         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2619         return;
2620     }
2621
2622     CHIP_ERROR err = self.cppCluster.ReadAttributeCoupleColorTempToLevelMinMireds(onSuccess->Cancel(), onFailure->Cancel());
2623     if (err != CHIP_NO_ERROR) {
2624         delete onSuccess;
2625         delete onFailure;
2626         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2627     }
2628 }
2629
2630 - (void)readAttributeStartUpColorTemperatureMireds:(ResponseHandler)completionHandler
2631 {
2632     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2633     if (!onSuccess) {
2634         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2635         return;
2636     }
2637
2638     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2639     if (!onFailure) {
2640         delete onSuccess;
2641         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2642         return;
2643     }
2644
2645     CHIP_ERROR err = self.cppCluster.ReadAttributeStartUpColorTemperatureMireds(onSuccess->Cancel(), onFailure->Cancel());
2646     if (err != CHIP_NO_ERROR) {
2647         delete onSuccess;
2648         delete onFailure;
2649         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2650     }
2651 }
2652
2653 - (void)writeAttributeStartUpColorTemperatureMireds:(uint16_t)value completionHandler:(ResponseHandler)completionHandler
2654 {
2655     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2656     if (!onSuccess) {
2657         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2658         return;
2659     }
2660
2661     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2662     if (!onFailure) {
2663         delete onSuccess;
2664         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2665         return;
2666     }
2667
2668     CHIP_ERROR err = self.cppCluster.WriteAttributeStartUpColorTemperatureMireds(onSuccess->Cancel(), onFailure->Cancel(), value);
2669     if (err != CHIP_NO_ERROR) {
2670         delete onSuccess;
2671         delete onFailure;
2672         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2673     }
2674 }
2675
2676 - (void)readAttributeClusterRevision:(ResponseHandler)completionHandler
2677 {
2678     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2679     if (!onSuccess) {
2680         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2681         return;
2682     }
2683
2684     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2685     if (!onFailure) {
2686         delete onSuccess;
2687         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2688         return;
2689     }
2690
2691     CHIP_ERROR err = self.cppCluster.ReadAttributeClusterRevision(onSuccess->Cancel(), onFailure->Cancel());
2692     if (err != CHIP_NO_ERROR) {
2693         delete onSuccess;
2694         delete onFailure;
2695         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2696     }
2697 }
2698
2699 @end
2700
2701 @interface CHIPDoorLock ()
2702 @property (readonly) Controller::DoorLockCluster cppCluster;
2703 @end
2704
2705 @implementation CHIPDoorLock
2706
2707 - (Controller::ClusterBase *)getCluster
2708 {
2709     return &_cppCluster;
2710 }
2711
2712 - (void)clearAllPins:(ResponseHandler)completionHandler
2713 {
2714     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2715     if (!onSuccess) {
2716         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2717         return;
2718     }
2719
2720     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2721     if (!onFailure) {
2722         delete onSuccess;
2723         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2724         return;
2725     }
2726
2727     CHIP_ERROR err = self.cppCluster.ClearAllPins(onSuccess->Cancel(), onFailure->Cancel());
2728     if (err != CHIP_NO_ERROR) {
2729         delete onSuccess;
2730         delete onFailure;
2731         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2732     }
2733 }
2734 - (void)clearAllRfids:(ResponseHandler)completionHandler
2735 {
2736     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2737     if (!onSuccess) {
2738         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2739         return;
2740     }
2741
2742     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2743     if (!onFailure) {
2744         delete onSuccess;
2745         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2746         return;
2747     }
2748
2749     CHIP_ERROR err = self.cppCluster.ClearAllRfids(onSuccess->Cancel(), onFailure->Cancel());
2750     if (err != CHIP_NO_ERROR) {
2751         delete onSuccess;
2752         delete onFailure;
2753         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2754     }
2755 }
2756 - (void)clearHolidaySchedule:(uint8_t)scheduleId completionHandler:(ResponseHandler)completionHandler
2757 {
2758     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2759     if (!onSuccess) {
2760         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2761         return;
2762     }
2763
2764     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2765     if (!onFailure) {
2766         delete onSuccess;
2767         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2768         return;
2769     }
2770
2771     CHIP_ERROR err = self.cppCluster.ClearHolidaySchedule(onSuccess->Cancel(), onFailure->Cancel(), scheduleId);
2772     if (err != CHIP_NO_ERROR) {
2773         delete onSuccess;
2774         delete onFailure;
2775         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2776     }
2777 }
2778 - (void)clearPin:(uint16_t)userId completionHandler:(ResponseHandler)completionHandler
2779 {
2780     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2781     if (!onSuccess) {
2782         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2783         return;
2784     }
2785
2786     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2787     if (!onFailure) {
2788         delete onSuccess;
2789         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2790         return;
2791     }
2792
2793     CHIP_ERROR err = self.cppCluster.ClearPin(onSuccess->Cancel(), onFailure->Cancel(), userId);
2794     if (err != CHIP_NO_ERROR) {
2795         delete onSuccess;
2796         delete onFailure;
2797         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2798     }
2799 }
2800 - (void)clearRfid:(uint16_t)userId completionHandler:(ResponseHandler)completionHandler
2801 {
2802     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2803     if (!onSuccess) {
2804         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2805         return;
2806     }
2807
2808     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2809     if (!onFailure) {
2810         delete onSuccess;
2811         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2812         return;
2813     }
2814
2815     CHIP_ERROR err = self.cppCluster.ClearRfid(onSuccess->Cancel(), onFailure->Cancel(), userId);
2816     if (err != CHIP_NO_ERROR) {
2817         delete onSuccess;
2818         delete onFailure;
2819         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2820     }
2821 }
2822 - (void)clearWeekdaySchedule:(uint8_t)scheduleId userId:(uint16_t)userId completionHandler:(ResponseHandler)completionHandler
2823 {
2824     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2825     if (!onSuccess) {
2826         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2827         return;
2828     }
2829
2830     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2831     if (!onFailure) {
2832         delete onSuccess;
2833         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2834         return;
2835     }
2836
2837     CHIP_ERROR err = self.cppCluster.ClearWeekdaySchedule(onSuccess->Cancel(), onFailure->Cancel(), scheduleId, userId);
2838     if (err != CHIP_NO_ERROR) {
2839         delete onSuccess;
2840         delete onFailure;
2841         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2842     }
2843 }
2844 - (void)clearYeardaySchedule:(uint8_t)scheduleId userId:(uint16_t)userId completionHandler:(ResponseHandler)completionHandler
2845 {
2846     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2847     if (!onSuccess) {
2848         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2849         return;
2850     }
2851
2852     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2853     if (!onFailure) {
2854         delete onSuccess;
2855         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2856         return;
2857     }
2858
2859     CHIP_ERROR err = self.cppCluster.ClearYeardaySchedule(onSuccess->Cancel(), onFailure->Cancel(), scheduleId, userId);
2860     if (err != CHIP_NO_ERROR) {
2861         delete onSuccess;
2862         delete onFailure;
2863         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2864     }
2865 }
2866 - (void)getHolidaySchedule:(uint8_t)scheduleId completionHandler:(ResponseHandler)completionHandler
2867 {
2868     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2869     if (!onSuccess) {
2870         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2871         return;
2872     }
2873
2874     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2875     if (!onFailure) {
2876         delete onSuccess;
2877         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2878         return;
2879     }
2880
2881     CHIP_ERROR err = self.cppCluster.GetHolidaySchedule(onSuccess->Cancel(), onFailure->Cancel(), scheduleId);
2882     if (err != CHIP_NO_ERROR) {
2883         delete onSuccess;
2884         delete onFailure;
2885         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2886     }
2887 }
2888 - (void)getLogRecord:(uint16_t)logIndex completionHandler:(ResponseHandler)completionHandler
2889 {
2890     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2891     if (!onSuccess) {
2892         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2893         return;
2894     }
2895
2896     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2897     if (!onFailure) {
2898         delete onSuccess;
2899         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2900         return;
2901     }
2902
2903     CHIP_ERROR err = self.cppCluster.GetLogRecord(onSuccess->Cancel(), onFailure->Cancel(), logIndex);
2904     if (err != CHIP_NO_ERROR) {
2905         delete onSuccess;
2906         delete onFailure;
2907         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2908     }
2909 }
2910 - (void)getPin:(uint16_t)userId completionHandler:(ResponseHandler)completionHandler
2911 {
2912     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2913     if (!onSuccess) {
2914         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2915         return;
2916     }
2917
2918     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2919     if (!onFailure) {
2920         delete onSuccess;
2921         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2922         return;
2923     }
2924
2925     CHIP_ERROR err = self.cppCluster.GetPin(onSuccess->Cancel(), onFailure->Cancel(), userId);
2926     if (err != CHIP_NO_ERROR) {
2927         delete onSuccess;
2928         delete onFailure;
2929         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2930     }
2931 }
2932 - (void)getRfid:(uint16_t)userId completionHandler:(ResponseHandler)completionHandler
2933 {
2934     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2935     if (!onSuccess) {
2936         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2937         return;
2938     }
2939
2940     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2941     if (!onFailure) {
2942         delete onSuccess;
2943         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2944         return;
2945     }
2946
2947     CHIP_ERROR err = self.cppCluster.GetRfid(onSuccess->Cancel(), onFailure->Cancel(), userId);
2948     if (err != CHIP_NO_ERROR) {
2949         delete onSuccess;
2950         delete onFailure;
2951         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2952     }
2953 }
2954 - (void)getUserType:(uint16_t)userId completionHandler:(ResponseHandler)completionHandler
2955 {
2956     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2957     if (!onSuccess) {
2958         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2959         return;
2960     }
2961
2962     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2963     if (!onFailure) {
2964         delete onSuccess;
2965         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2966         return;
2967     }
2968
2969     CHIP_ERROR err = self.cppCluster.GetUserType(onSuccess->Cancel(), onFailure->Cancel(), userId);
2970     if (err != CHIP_NO_ERROR) {
2971         delete onSuccess;
2972         delete onFailure;
2973         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2974     }
2975 }
2976 - (void)getWeekdaySchedule:(uint8_t)scheduleId userId:(uint16_t)userId completionHandler:(ResponseHandler)completionHandler
2977 {
2978     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2979     if (!onSuccess) {
2980         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2981         return;
2982     }
2983
2984     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2985     if (!onFailure) {
2986         delete onSuccess;
2987         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2988         return;
2989     }
2990
2991     CHIP_ERROR err = self.cppCluster.GetWeekdaySchedule(onSuccess->Cancel(), onFailure->Cancel(), scheduleId, userId);
2992     if (err != CHIP_NO_ERROR) {
2993         delete onSuccess;
2994         delete onFailure;
2995         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2996     }
2997 }
2998 - (void)getYeardaySchedule:(uint8_t)scheduleId userId:(uint16_t)userId completionHandler:(ResponseHandler)completionHandler
2999 {
3000     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
3001     if (!onSuccess) {
3002         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3003         return;
3004     }
3005
3006     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3007     if (!onFailure) {
3008         delete onSuccess;
3009         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3010         return;
3011     }
3012
3013     CHIP_ERROR err = self.cppCluster.GetYeardaySchedule(onSuccess->Cancel(), onFailure->Cancel(), scheduleId, userId);
3014     if (err != CHIP_NO_ERROR) {
3015         delete onSuccess;
3016         delete onFailure;
3017         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3018     }
3019 }
3020 - (void)lockDoor:(NSString *)pin completionHandler:(ResponseHandler)completionHandler
3021 {
3022     CHIPDoorLockClusterLockDoorResponseCallbackBridge * onSuccess
3023         = new CHIPDoorLockClusterLockDoorResponseCallbackBridge(completionHandler, [self callbackQueue]);
3024     if (!onSuccess) {
3025         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3026         return;
3027     }
3028
3029     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3030     if (!onFailure) {
3031         delete onSuccess;
3032         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3033         return;
3034     }
3035
3036     CHIP_ERROR err = self.cppCluster.LockDoor(onSuccess->Cancel(), onFailure->Cancel(),
3037         chip::ByteSpan((const uint8_t *) [pin dataUsingEncoding:NSUTF8StringEncoding].bytes,
3038             [pin lengthOfBytesUsingEncoding:NSUTF8StringEncoding]));
3039     if (err != CHIP_NO_ERROR) {
3040         delete onSuccess;
3041         delete onFailure;
3042         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3043     }
3044 }
3045 - (void)setHolidaySchedule:(uint8_t)scheduleId
3046                 localStartTime:(uint32_t)localStartTime
3047                   localEndTime:(uint32_t)localEndTime
3048     operatingModeDuringHoliday:(uint8_t)operatingModeDuringHoliday
3049              completionHandler:(ResponseHandler)completionHandler
3050 {
3051     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
3052     if (!onSuccess) {
3053         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3054         return;
3055     }
3056
3057     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3058     if (!onFailure) {
3059         delete onSuccess;
3060         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3061         return;
3062     }
3063
3064     CHIP_ERROR err = self.cppCluster.SetHolidaySchedule(
3065         onSuccess->Cancel(), onFailure->Cancel(), scheduleId, localStartTime, localEndTime, operatingModeDuringHoliday);
3066     if (err != CHIP_NO_ERROR) {
3067         delete onSuccess;
3068         delete onFailure;
3069         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3070     }
3071 }
3072 - (void)setPin:(uint16_t)userId
3073            userStatus:(uint8_t)userStatus
3074              userType:(uint8_t)userType
3075                   pin:(NSString *)pin
3076     completionHandler:(ResponseHandler)completionHandler
3077 {
3078     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
3079     if (!onSuccess) {
3080         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3081         return;
3082     }
3083
3084     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3085     if (!onFailure) {
3086         delete onSuccess;
3087         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3088         return;
3089     }
3090
3091     CHIP_ERROR err = self.cppCluster.SetPin(onSuccess->Cancel(), onFailure->Cancel(), userId, userStatus, userType,
3092         chip::ByteSpan((const uint8_t *) [pin dataUsingEncoding:NSUTF8StringEncoding].bytes,
3093             [pin lengthOfBytesUsingEncoding:NSUTF8StringEncoding]));
3094     if (err != CHIP_NO_ERROR) {
3095         delete onSuccess;
3096         delete onFailure;
3097         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3098     }
3099 }
3100 - (void)setRfid:(uint16_t)userId
3101            userStatus:(uint8_t)userStatus
3102              userType:(uint8_t)userType
3103                    id:(NSString *)id
3104     completionHandler:(ResponseHandler)completionHandler
3105 {
3106     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
3107     if (!onSuccess) {
3108         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3109         return;
3110     }
3111
3112     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3113     if (!onFailure) {
3114         delete onSuccess;
3115         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3116         return;
3117     }
3118
3119     CHIP_ERROR err = self.cppCluster.SetRfid(onSuccess->Cancel(), onFailure->Cancel(), userId, userStatus, userType,
3120         chip::ByteSpan((const uint8_t *) [id dataUsingEncoding:NSUTF8StringEncoding].bytes,
3121             [id lengthOfBytesUsingEncoding:NSUTF8StringEncoding]));
3122     if (err != CHIP_NO_ERROR) {
3123         delete onSuccess;
3124         delete onFailure;
3125         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3126     }
3127 }
3128 - (void)setUserType:(uint16_t)userId userType:(uint8_t)userType completionHandler:(ResponseHandler)completionHandler
3129 {
3130     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
3131     if (!onSuccess) {
3132         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3133         return;
3134     }
3135
3136     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3137     if (!onFailure) {
3138         delete onSuccess;
3139         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3140         return;
3141     }
3142
3143     CHIP_ERROR err = self.cppCluster.SetUserType(onSuccess->Cancel(), onFailure->Cancel(), userId, userType);
3144     if (err != CHIP_NO_ERROR) {
3145         delete onSuccess;
3146         delete onFailure;
3147         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3148     }
3149 }
3150 - (void)setWeekdaySchedule:(uint8_t)scheduleId
3151                     userId:(uint16_t)userId
3152                   daysMask:(uint8_t)daysMask
3153                  startHour:(uint8_t)startHour
3154                startMinute:(uint8_t)startMinute
3155                    endHour:(uint8_t)endHour
3156                  endMinute:(uint8_t)endMinute
3157          completionHandler:(ResponseHandler)completionHandler
3158 {
3159     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
3160     if (!onSuccess) {
3161         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3162         return;
3163     }
3164
3165     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3166     if (!onFailure) {
3167         delete onSuccess;
3168         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3169         return;
3170     }
3171
3172     CHIP_ERROR err = self.cppCluster.SetWeekdaySchedule(
3173         onSuccess->Cancel(), onFailure->Cancel(), scheduleId, userId, daysMask, startHour, startMinute, endHour, endMinute);
3174     if (err != CHIP_NO_ERROR) {
3175         delete onSuccess;
3176         delete onFailure;
3177         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3178     }
3179 }
3180 - (void)setYeardaySchedule:(uint8_t)scheduleId
3181                     userId:(uint16_t)userId
3182             localStartTime:(uint32_t)localStartTime
3183               localEndTime:(uint32_t)localEndTime
3184          completionHandler:(ResponseHandler)completionHandler
3185 {
3186     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
3187     if (!onSuccess) {
3188         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3189         return;
3190     }
3191
3192     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3193     if (!onFailure) {
3194         delete onSuccess;
3195         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3196         return;
3197     }
3198
3199     CHIP_ERROR err = self.cppCluster.SetYeardaySchedule(
3200         onSuccess->Cancel(), onFailure->Cancel(), scheduleId, userId, localStartTime, localEndTime);
3201     if (err != CHIP_NO_ERROR) {
3202         delete onSuccess;
3203         delete onFailure;
3204         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3205     }
3206 }
3207 - (void)unlockDoor:(NSString *)pin completionHandler:(ResponseHandler)completionHandler
3208 {
3209     CHIPDoorLockClusterUnlockDoorResponseCallbackBridge * onSuccess
3210         = new CHIPDoorLockClusterUnlockDoorResponseCallbackBridge(completionHandler, [self callbackQueue]);
3211     if (!onSuccess) {
3212         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3213         return;
3214     }
3215
3216     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3217     if (!onFailure) {
3218         delete onSuccess;
3219         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3220         return;
3221     }
3222
3223     CHIP_ERROR err = self.cppCluster.UnlockDoor(onSuccess->Cancel(), onFailure->Cancel(),
3224         chip::ByteSpan((const uint8_t *) [pin dataUsingEncoding:NSUTF8StringEncoding].bytes,
3225             [pin lengthOfBytesUsingEncoding:NSUTF8StringEncoding]));
3226     if (err != CHIP_NO_ERROR) {
3227         delete onSuccess;
3228         delete onFailure;
3229         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3230     }
3231 }
3232 - (void)unlockWithTimeout:(uint16_t)timeoutInSeconds pin:(NSString *)pin completionHandler:(ResponseHandler)completionHandler
3233 {
3234     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
3235     if (!onSuccess) {
3236         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3237         return;
3238     }
3239
3240     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3241     if (!onFailure) {
3242         delete onSuccess;
3243         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3244         return;
3245     }
3246
3247     CHIP_ERROR err = self.cppCluster.UnlockWithTimeout(onSuccess->Cancel(), onFailure->Cancel(), timeoutInSeconds,
3248         chip::ByteSpan((const uint8_t *) [pin dataUsingEncoding:NSUTF8StringEncoding].bytes,
3249             [pin lengthOfBytesUsingEncoding:NSUTF8StringEncoding]));
3250     if (err != CHIP_NO_ERROR) {
3251         delete onSuccess;
3252         delete onFailure;
3253         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3254     }
3255 }
3256
3257 - (void)readAttributeLockState:(ResponseHandler)completionHandler
3258 {
3259     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
3260     if (!onSuccess) {
3261         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3262         return;
3263     }
3264
3265     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3266     if (!onFailure) {
3267         delete onSuccess;
3268         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3269         return;
3270     }
3271
3272     CHIP_ERROR err = self.cppCluster.ReadAttributeLockState(onSuccess->Cancel(), onFailure->Cancel());
3273     if (err != CHIP_NO_ERROR) {
3274         delete onSuccess;
3275         delete onFailure;
3276         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3277     }
3278 }
3279
3280 - (void)configureAttributeLockState:(uint16_t)minInterval
3281                         maxInterval:(uint16_t)maxInterval
3282                   completionHandler:(ResponseHandler)completionHandler
3283 {
3284     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
3285     if (!onSuccess) {
3286         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3287         return;
3288     }
3289
3290     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3291     if (!onFailure) {
3292         delete onSuccess;
3293         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3294         return;
3295     }
3296
3297     CHIP_ERROR err
3298         = self.cppCluster.ConfigureAttributeLockState(onSuccess->Cancel(), onFailure->Cancel(), minInterval, maxInterval);
3299     if (err != CHIP_NO_ERROR) {
3300         delete onSuccess;
3301         delete onFailure;
3302         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3303     }
3304 }
3305
3306 - (void)reportAttributeLockState:(ResponseHandler)reportHandler
3307 {
3308     CHIPInt8uAttributeCallbackBridge * onReport = new CHIPInt8uAttributeCallbackBridge(reportHandler, [self callbackQueue], true);
3309     if (!onReport) {
3310         reportHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3311         return;
3312     }
3313
3314     CHIP_ERROR err = self.cppCluster.ReportAttributeLockState(onReport->Cancel());
3315     if (err != CHIP_NO_ERROR) {
3316         delete onReport;
3317         reportHandler([CHIPError errorForCHIPErrorCode:err], nil);
3318     }
3319 }
3320
3321 - (void)readAttributeLockType:(ResponseHandler)completionHandler
3322 {
3323     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
3324     if (!onSuccess) {
3325         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3326         return;
3327     }
3328
3329     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3330     if (!onFailure) {
3331         delete onSuccess;
3332         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3333         return;
3334     }
3335
3336     CHIP_ERROR err = self.cppCluster.ReadAttributeLockType(onSuccess->Cancel(), onFailure->Cancel());
3337     if (err != CHIP_NO_ERROR) {
3338         delete onSuccess;
3339         delete onFailure;
3340         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3341     }
3342 }
3343
3344 - (void)readAttributeActuatorEnabled:(ResponseHandler)completionHandler
3345 {
3346     CHIPBooleanAttributeCallbackBridge * onSuccess
3347         = new CHIPBooleanAttributeCallbackBridge(completionHandler, [self callbackQueue]);
3348     if (!onSuccess) {
3349         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3350         return;
3351     }
3352
3353     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3354     if (!onFailure) {
3355         delete onSuccess;
3356         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3357         return;
3358     }
3359
3360     CHIP_ERROR err = self.cppCluster.ReadAttributeActuatorEnabled(onSuccess->Cancel(), onFailure->Cancel());
3361     if (err != CHIP_NO_ERROR) {
3362         delete onSuccess;
3363         delete onFailure;
3364         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3365     }
3366 }
3367
3368 - (void)readAttributeClusterRevision:(ResponseHandler)completionHandler
3369 {
3370     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
3371     if (!onSuccess) {
3372         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3373         return;
3374     }
3375
3376     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3377     if (!onFailure) {
3378         delete onSuccess;
3379         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3380         return;
3381     }
3382
3383     CHIP_ERROR err = self.cppCluster.ReadAttributeClusterRevision(onSuccess->Cancel(), onFailure->Cancel());
3384     if (err != CHIP_NO_ERROR) {
3385         delete onSuccess;
3386         delete onFailure;
3387         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3388     }
3389 }
3390
3391 @end