src/darwin/Framework/CHIP/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 = [NSError errorWithDomain:CHIPErrorDomain
  78                                                       code:status
  79                                                   userInfo:@ { NSLocalizedDescriptionKey : @"" }];
  80                 callback->mHandler(error, nil);
  81                 callback->Cancel();
  82                 delete callback;
  83             });
  84         }
  85     };
  86
  87 private:
  88     ResponseHandler mHandler;
  89     dispatch_queue_t mQueue;
  90 };
  91
  92 class CHIPUnsupportedAttributeCallbackBridge : public Callback::Callback<DefaultSuccessCallback> {
  93 public:
  94     CHIPUnsupportedAttributeCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
  95         : Callback::Callback<DefaultSuccessCallback>(CallbackFn, this)
  96     {
  97     }
  98
  99     ~CHIPUnsupportedAttributeCallbackBridge() {};
 100
 101     static void CallbackFn(void * context)
 102     {
 103         CHIPUnsupportedAttributeCallbackBridge * callback = reinterpret_cast<CHIPUnsupportedAttributeCallbackBridge *>(context);
 104         if (callback && callback->mQueue) {
 105             dispatch_async(callback->mQueue, ^{
 106                 NSError * error = [NSError errorWithDomain:CHIPErrorDomain
 107                                                       code:CHIPErrorCodeUndefinedError
 108                                                   userInfo:@ { NSLocalizedDescriptionKey : @"Unsupported attribute type" }];
 109                 callback->mHandler(error, nil);
 110                 callback->Cancel();
 111                 delete callback;
 112             });
 113         }
 114     };
 115
 116 private:
 117     ResponseHandler mHandler;
 118     dispatch_queue_t mQueue;
 119 };
 120
 121 class CHIPBooleanAttributeCallbackBridge : public Callback::Callback<BooleanAttributeCallback> {
 122 public:
 123     CHIPBooleanAttributeCallbackBridge(ResponseHandler handler, dispatch_queue_t queue, bool keepAlive = false)
 124         : Callback::Callback<BooleanAttributeCallback>(CallbackFn, this)
 125         , mHandler(handler)
 126         , mQueue(queue)
 127         , mKeepAlive(keepAlive)
 128     {
 129     }
 130
 131     ~CHIPBooleanAttributeCallbackBridge() {};
 132
 133     static void CallbackFn(void * context, bool value)
 134     {
 135         CHIPBooleanAttributeCallbackBridge * callback = reinterpret_cast<CHIPBooleanAttributeCallbackBridge *>(context);
 136         if (callback && callback->mQueue) {
 137             dispatch_async(callback->mQueue, ^{
 138                 callback->mHandler(nil, @ { @"value" : [NSNumber numberWithBool:value] });
 139                 if (!callback->mKeepAlive) {
 140                     callback->Cancel();
 141                     delete callback;
 142                 }
 143             });
 144         }
 145     };
 146
 147 private:
 148     ResponseHandler mHandler;
 149     dispatch_queue_t mQueue;
 150     bool mKeepAlive;
 151 };
 152
 153 class CHIPInt8uAttributeCallbackBridge : public Callback::Callback<Int8uAttributeCallback> {
 154 public:
 155     CHIPInt8uAttributeCallbackBridge(ResponseHandler handler, dispatch_queue_t queue, bool keepAlive = false)
 156         : Callback::Callback<Int8uAttributeCallback>(CallbackFn, this)
 157         , mHandler(handler)
 158         , mQueue(queue)
 159         , mKeepAlive(keepAlive)
 160     {
 161     }
 162
 163     ~CHIPInt8uAttributeCallbackBridge() {};
 164
 165     static void CallbackFn(void * context, uint8_t value)
 166     {
 167         CHIPInt8uAttributeCallbackBridge * callback = reinterpret_cast<CHIPInt8uAttributeCallbackBridge *>(context);
 168         if (callback && callback->mQueue) {
 169             dispatch_async(callback->mQueue, ^{
 170                 callback->mHandler(nil, @ { @"value" : [NSNumber numberWithUnsignedChar:value] });
 171                 if (!callback->mKeepAlive) {
 172                     callback->Cancel();
 173                     delete callback;
 174                 }
 175             });
 176         }
 177     };
 178
 179 private:
 180     ResponseHandler mHandler;
 181     dispatch_queue_t mQueue;
 182     bool mKeepAlive;
 183 };
 184
 185 class CHIPInt8sAttributeCallbackBridge : public Callback::Callback<Int8sAttributeCallback> {
 186 public:
 187     CHIPInt8sAttributeCallbackBridge(ResponseHandler handler, dispatch_queue_t queue, bool keepAlive = false)
 188         : Callback::Callback<Int8sAttributeCallback>(CallbackFn, this)
 189         , mHandler(handler)
 190         , mQueue(queue)
 191         , mKeepAlive(keepAlive)
 192     {
 193     }
 194
 195     ~CHIPInt8sAttributeCallbackBridge() {};
 196
 197     static void CallbackFn(void * context, int8_t value)
 198     {
 199         CHIPInt8sAttributeCallbackBridge * callback = reinterpret_cast<CHIPInt8sAttributeCallbackBridge *>(context);
 200         if (callback && callback->mQueue) {
 201             dispatch_async(callback->mQueue, ^{
 202                 callback->mHandler(nil, @ { @"value" : [NSNumber numberWithChar:value] });
 203                 if (!callback->mKeepAlive) {
 204                     callback->Cancel();
 205                     delete callback;
 206                 }
 207             });
 208         }
 209     };
 210
 211 private:
 212     ResponseHandler mHandler;
 213     dispatch_queue_t mQueue;
 214     bool mKeepAlive;
 215 };
 216
 217 class CHIPInt16uAttributeCallbackBridge : public Callback::Callback<Int16uAttributeCallback> {
 218 public:
 219     CHIPInt16uAttributeCallbackBridge(ResponseHandler handler, dispatch_queue_t queue, bool keepAlive = false)
 220         : Callback::Callback<Int16uAttributeCallback>(CallbackFn, this)
 221         , mHandler(handler)
 222         , mQueue(queue)
 223         , mKeepAlive(keepAlive)
 224     {
 225     }
 226
 227     ~CHIPInt16uAttributeCallbackBridge() {};
 228
 229     static void CallbackFn(void * context, uint16_t value)
 230     {
 231         CHIPInt16uAttributeCallbackBridge * callback = reinterpret_cast<CHIPInt16uAttributeCallbackBridge *>(context);
 232         if (callback && callback->mQueue) {
 233             dispatch_async(callback->mQueue, ^{
 234                 callback->mHandler(nil, @ { @"value" : [NSNumber numberWithUnsignedShort:value] });
 235                 if (!callback->mKeepAlive) {
 236                     callback->Cancel();
 237                     delete callback;
 238                 }
 239             });
 240         }
 241     };
 242
 243 private:
 244     ResponseHandler mHandler;
 245     dispatch_queue_t mQueue;
 246     bool mKeepAlive;
 247 };
 248
 249 class CHIPInt16sAttributeCallbackBridge : public Callback::Callback<Int16sAttributeCallback> {
 250 public:
 251     CHIPInt16sAttributeCallbackBridge(ResponseHandler handler, dispatch_queue_t queue, bool keepAlive = false)
 252         : Callback::Callback<Int16sAttributeCallback>(CallbackFn, this)
 253         , mHandler(handler)
 254         , mQueue(queue)
 255         , mKeepAlive(keepAlive)
 256     {
 257     }
 258
 259     ~CHIPInt16sAttributeCallbackBridge() {};
 260
 261     static void CallbackFn(void * context, int16_t value)
 262     {
 263         CHIPInt16sAttributeCallbackBridge * callback = reinterpret_cast<CHIPInt16sAttributeCallbackBridge *>(context);
 264         if (callback && callback->mQueue) {
 265             dispatch_async(callback->mQueue, ^{
 266                 callback->mHandler(nil, @ { @"value" : [NSNumber numberWithShort:value] });
 267                 if (!callback->mKeepAlive) {
 268                     callback->Cancel();
 269                     delete callback;
 270                 }
 271             });
 272         }
 273     };
 274
 275 private:
 276     ResponseHandler mHandler;
 277     dispatch_queue_t mQueue;
 278     bool mKeepAlive;
 279 };
 280
 281 class CHIPDoorLockClusterClearAllPinsResponseCallbackBridge
 282     : public Callback::Callback<DoorLockClusterClearAllPinsResponseCallback> {
 283 public:
 284     CHIPDoorLockClusterClearAllPinsResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
 285         : Callback::Callback<DoorLockClusterClearAllPinsResponseCallback>(CallbackFn, this)
 286         , mHandler(handler)
 287         , mQueue(queue)
 288     {
 289     }
 290
 291     ~CHIPDoorLockClusterClearAllPinsResponseCallbackBridge() {};
 292
 293     static void CallbackFn(void * context)
 294     {
 295         CHIPDoorLockClusterClearAllPinsResponseCallbackBridge * callback
 296             = reinterpret_cast<CHIPDoorLockClusterClearAllPinsResponseCallbackBridge *>(context);
 297         if (callback && callback->mQueue) {
 298             dispatch_async(callback->mQueue, ^{
 299                 callback->mHandler(nil, @ {});
 300                 callback->Cancel();
 301                 delete callback;
 302             });
 303         }
 304     };
 305
 306 private:
 307     ResponseHandler mHandler;
 308     dispatch_queue_t mQueue;
 309 };
 310
 311 class CHIPDoorLockClusterClearAllRfidsResponseCallbackBridge
 312     : public Callback::Callback<DoorLockClusterClearAllRfidsResponseCallback> {
 313 public:
 314     CHIPDoorLockClusterClearAllRfidsResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
 315         : Callback::Callback<DoorLockClusterClearAllRfidsResponseCallback>(CallbackFn, this)
 316         , mHandler(handler)
 317         , mQueue(queue)
 318     {
 319     }
 320
 321     ~CHIPDoorLockClusterClearAllRfidsResponseCallbackBridge() {};
 322
 323     static void CallbackFn(void * context)
 324     {
 325         CHIPDoorLockClusterClearAllRfidsResponseCallbackBridge * callback
 326             = reinterpret_cast<CHIPDoorLockClusterClearAllRfidsResponseCallbackBridge *>(context);
 327         if (callback && callback->mQueue) {
 328             dispatch_async(callback->mQueue, ^{
 329                 callback->mHandler(nil, @ {});
 330                 callback->Cancel();
 331                 delete callback;
 332             });
 333         }
 334     };
 335
 336 private:
 337     ResponseHandler mHandler;
 338     dispatch_queue_t mQueue;
 339 };
 340
 341 class CHIPDoorLockClusterClearHolidayScheduleResponseCallbackBridge
 342     : public Callback::Callback<DoorLockClusterClearHolidayScheduleResponseCallback> {
 343 public:
 344     CHIPDoorLockClusterClearHolidayScheduleResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
 345         : Callback::Callback<DoorLockClusterClearHolidayScheduleResponseCallback>(CallbackFn, this)
 346         , mHandler(handler)
 347         , mQueue(queue)
 348     {
 349     }
 350
 351     ~CHIPDoorLockClusterClearHolidayScheduleResponseCallbackBridge() {};
 352
 353     static void CallbackFn(void * context)
 354     {
 355         CHIPDoorLockClusterClearHolidayScheduleResponseCallbackBridge * callback
 356             = reinterpret_cast<CHIPDoorLockClusterClearHolidayScheduleResponseCallbackBridge *>(context);
 357         if (callback && callback->mQueue) {
 358             dispatch_async(callback->mQueue, ^{
 359                 callback->mHandler(nil, @ {});
 360                 callback->Cancel();
 361                 delete callback;
 362             });
 363         }
 364     };
 365
 366 private:
 367     ResponseHandler mHandler;
 368     dispatch_queue_t mQueue;
 369 };
 370
 371 class CHIPDoorLockClusterClearPinResponseCallbackBridge : public Callback::Callback<DoorLockClusterClearPinResponseCallback> {
 372 public:
 373     CHIPDoorLockClusterClearPinResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
 374         : Callback::Callback<DoorLockClusterClearPinResponseCallback>(CallbackFn, this)
 375         , mHandler(handler)
 376         , mQueue(queue)
 377     {
 378     }
 379
 380     ~CHIPDoorLockClusterClearPinResponseCallbackBridge() {};
 381
 382     static void CallbackFn(void * context)
 383     {
 384         CHIPDoorLockClusterClearPinResponseCallbackBridge * callback
 385             = reinterpret_cast<CHIPDoorLockClusterClearPinResponseCallbackBridge *>(context);
 386         if (callback && callback->mQueue) {
 387             dispatch_async(callback->mQueue, ^{
 388                 callback->mHandler(nil, @ {});
 389                 callback->Cancel();
 390                 delete callback;
 391             });
 392         }
 393     };
 394
 395 private:
 396     ResponseHandler mHandler;
 397     dispatch_queue_t mQueue;
 398 };
 399
 400 class CHIPDoorLockClusterClearRfidResponseCallbackBridge : public Callback::Callback<DoorLockClusterClearRfidResponseCallback> {
 401 public:
 402     CHIPDoorLockClusterClearRfidResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
 403         : Callback::Callback<DoorLockClusterClearRfidResponseCallback>(CallbackFn, this)
 404         , mHandler(handler)
 405         , mQueue(queue)
 406     {
 407     }
 408
 409     ~CHIPDoorLockClusterClearRfidResponseCallbackBridge() {};
 410
 411     static void CallbackFn(void * context)
 412     {
 413         CHIPDoorLockClusterClearRfidResponseCallbackBridge * callback
 414             = reinterpret_cast<CHIPDoorLockClusterClearRfidResponseCallbackBridge *>(context);
 415         if (callback && callback->mQueue) {
 416             dispatch_async(callback->mQueue, ^{
 417                 callback->mHandler(nil, @ {});
 418                 callback->Cancel();
 419                 delete callback;
 420             });
 421         }
 422     };
 423
 424 private:
 425     ResponseHandler mHandler;
 426     dispatch_queue_t mQueue;
 427 };
 428
 429 class CHIPDoorLockClusterClearWeekdayScheduleResponseCallbackBridge
 430     : public Callback::Callback<DoorLockClusterClearWeekdayScheduleResponseCallback> {
 431 public:
 432     CHIPDoorLockClusterClearWeekdayScheduleResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
 433         : Callback::Callback<DoorLockClusterClearWeekdayScheduleResponseCallback>(CallbackFn, this)
 434         , mHandler(handler)
 435         , mQueue(queue)
 436     {
 437     }
 438
 439     ~CHIPDoorLockClusterClearWeekdayScheduleResponseCallbackBridge() {};
 440
 441     static void CallbackFn(void * context)
 442     {
 443         CHIPDoorLockClusterClearWeekdayScheduleResponseCallbackBridge * callback
 444             = reinterpret_cast<CHIPDoorLockClusterClearWeekdayScheduleResponseCallbackBridge *>(context);
 445         if (callback && callback->mQueue) {
 446             dispatch_async(callback->mQueue, ^{
 447                 callback->mHandler(nil, @ {});
 448                 callback->Cancel();
 449                 delete callback;
 450             });
 451         }
 452     };
 453
 454 private:
 455     ResponseHandler mHandler;
 456     dispatch_queue_t mQueue;
 457 };
 458
 459 class CHIPDoorLockClusterClearYeardayScheduleResponseCallbackBridge
 460     : public Callback::Callback<DoorLockClusterClearYeardayScheduleResponseCallback> {
 461 public:
 462     CHIPDoorLockClusterClearYeardayScheduleResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
 463         : Callback::Callback<DoorLockClusterClearYeardayScheduleResponseCallback>(CallbackFn, this)
 464         , mHandler(handler)
 465         , mQueue(queue)
 466     {
 467     }
 468
 469     ~CHIPDoorLockClusterClearYeardayScheduleResponseCallbackBridge() {};
 470
 471     static void CallbackFn(void * context)
 472     {
 473         CHIPDoorLockClusterClearYeardayScheduleResponseCallbackBridge * callback
 474             = reinterpret_cast<CHIPDoorLockClusterClearYeardayScheduleResponseCallbackBridge *>(context);
 475         if (callback && callback->mQueue) {
 476             dispatch_async(callback->mQueue, ^{
 477                 callback->mHandler(nil, @ {});
 478                 callback->Cancel();
 479                 delete callback;
 480             });
 481         }
 482     };
 483
 484 private:
 485     ResponseHandler mHandler;
 486     dispatch_queue_t mQueue;
 487 };
 488
 489 class CHIPDoorLockClusterGetHolidayScheduleResponseCallbackBridge
 490     : public Callback::Callback<DoorLockClusterGetHolidayScheduleResponseCallback> {
 491 public:
 492     CHIPDoorLockClusterGetHolidayScheduleResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
 493         : Callback::Callback<DoorLockClusterGetHolidayScheduleResponseCallback>(CallbackFn, this)
 494         , mHandler(handler)
 495         , mQueue(queue)
 496     {
 497     }
 498
 499     ~CHIPDoorLockClusterGetHolidayScheduleResponseCallbackBridge() {};
 500
 501     static void CallbackFn(
 502         void * context, uint8_t scheduleId, uint32_t localStartTime, uint32_t localEndTime, uint8_t operatingModeDuringHoliday)
 503     {
 504         CHIPDoorLockClusterGetHolidayScheduleResponseCallbackBridge * callback
 505             = reinterpret_cast<CHIPDoorLockClusterGetHolidayScheduleResponseCallbackBridge *>(context);
 506         if (callback && callback->mQueue) {
 507             dispatch_async(callback->mQueue, ^{
 508                 callback->mHandler(nil, @ {
 509                     @"scheduleId" : [NSNumber numberWithUnsignedChar:scheduleId],
 510                     @"localStartTime" : [NSNumber numberWithUnsignedLong:localStartTime],
 511                     @"localEndTime" : [NSNumber numberWithUnsignedLong:localEndTime],
 512                     @"operatingModeDuringHoliday" : [NSNumber numberWithUnsignedChar:operatingModeDuringHoliday],
 513                 });
 514                 callback->Cancel();
 515                 delete callback;
 516             });
 517         }
 518     };
 519
 520 private:
 521     ResponseHandler mHandler;
 522     dispatch_queue_t mQueue;
 523 };
 524
 525 class CHIPDoorLockClusterGetLogRecordResponseCallbackBridge
 526     : public Callback::Callback<DoorLockClusterGetLogRecordResponseCallback> {
 527 public:
 528     CHIPDoorLockClusterGetLogRecordResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
 529         : Callback::Callback<DoorLockClusterGetLogRecordResponseCallback>(CallbackFn, this)
 530         , mHandler(handler)
 531         , mQueue(queue)
 532     {
 533     }
 534
 535     ~CHIPDoorLockClusterGetLogRecordResponseCallbackBridge() {};
 536
 537     static void CallbackFn(void * context, uint16_t logEntryId, uint32_t timestamp, uint8_t eventType, uint8_t source,
 538         uint8_t eventIdOrAlarmCode, uint16_t userId, uint8_t * pin)
 539     {
 540         CHIPDoorLockClusterGetLogRecordResponseCallbackBridge * callback
 541             = reinterpret_cast<CHIPDoorLockClusterGetLogRecordResponseCallbackBridge *>(context);
 542         if (callback && callback->mQueue) {
 543             dispatch_async(callback->mQueue, ^{
 544                 callback->mHandler(nil, @ {
 545                     @"logEntryId" : [NSNumber numberWithUnsignedShort:logEntryId],
 546                     @"timestamp" : [NSNumber numberWithUnsignedLong:timestamp],
 547                     @"eventType" : [NSNumber numberWithUnsignedChar:eventType],
 548                     @"source" : [NSNumber numberWithUnsignedChar:source],
 549                     @"eventIdOrAlarmCode" : [NSNumber numberWithUnsignedChar:eventIdOrAlarmCode],
 550                     @"userId" : [NSNumber numberWithUnsignedShort:userId],
 551                     @"pin" : [NSString stringWithFormat:@"%s", pin],
 552                 });
 553                 callback->Cancel();
 554                 delete callback;
 555             });
 556         }
 557     };
 558
 559 private:
 560     ResponseHandler mHandler;
 561     dispatch_queue_t mQueue;
 562 };
 563
 564 class CHIPDoorLockClusterGetPinResponseCallbackBridge : public Callback::Callback<DoorLockClusterGetPinResponseCallback> {
 565 public:
 566     CHIPDoorLockClusterGetPinResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
 567         : Callback::Callback<DoorLockClusterGetPinResponseCallback>(CallbackFn, this)
 568         , mHandler(handler)
 569         , mQueue(queue)
 570     {
 571     }
 572
 573     ~CHIPDoorLockClusterGetPinResponseCallbackBridge() {};
 574
 575     static void CallbackFn(void * context, uint16_t userId, uint8_t userStatus, uint8_t userType, uint8_t * pin)
 576     {
 577         CHIPDoorLockClusterGetPinResponseCallbackBridge * callback
 578             = reinterpret_cast<CHIPDoorLockClusterGetPinResponseCallbackBridge *>(context);
 579         if (callback && callback->mQueue) {
 580             dispatch_async(callback->mQueue, ^{
 581                 callback->mHandler(nil, @ {
 582                     @"userId" : [NSNumber numberWithUnsignedShort:userId],
 583                     @"userStatus" : [NSNumber numberWithUnsignedChar:userStatus],
 584                     @"userType" : [NSNumber numberWithUnsignedChar:userType],
 585                     @"pin" : [NSString stringWithFormat:@"%s", pin],
 586                 });
 587                 callback->Cancel();
 588                 delete callback;
 589             });
 590         }
 591     };
 592
 593 private:
 594     ResponseHandler mHandler;
 595     dispatch_queue_t mQueue;
 596 };
 597
 598 class CHIPDoorLockClusterGetRfidResponseCallbackBridge : public Callback::Callback<DoorLockClusterGetRfidResponseCallback> {
 599 public:
 600     CHIPDoorLockClusterGetRfidResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
 601         : Callback::Callback<DoorLockClusterGetRfidResponseCallback>(CallbackFn, this)
 602         , mHandler(handler)
 603         , mQueue(queue)
 604     {
 605     }
 606
 607     ~CHIPDoorLockClusterGetRfidResponseCallbackBridge() {};
 608
 609     static void CallbackFn(void * context, uint16_t userId, uint8_t userStatus, uint8_t userType, uint8_t * rfid)
 610     {
 611         CHIPDoorLockClusterGetRfidResponseCallbackBridge * callback
 612             = reinterpret_cast<CHIPDoorLockClusterGetRfidResponseCallbackBridge *>(context);
 613         if (callback && callback->mQueue) {
 614             dispatch_async(callback->mQueue, ^{
 615                 callback->mHandler(nil, @ {
 616                     @"userId" : [NSNumber numberWithUnsignedShort:userId],
 617                     @"userStatus" : [NSNumber numberWithUnsignedChar:userStatus],
 618                     @"userType" : [NSNumber numberWithUnsignedChar:userType],
 619                     @"rfid" : [NSString stringWithFormat:@"%s", rfid],
 620                 });
 621                 callback->Cancel();
 622                 delete callback;
 623             });
 624         }
 625     };
 626
 627 private:
 628     ResponseHandler mHandler;
 629     dispatch_queue_t mQueue;
 630 };
 631
 632 class CHIPDoorLockClusterGetUserTypeResponseCallbackBridge : public Callback::Callback<DoorLockClusterGetUserTypeResponseCallback> {
 633 public:
 634     CHIPDoorLockClusterGetUserTypeResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
 635         : Callback::Callback<DoorLockClusterGetUserTypeResponseCallback>(CallbackFn, this)
 636         , mHandler(handler)
 637         , mQueue(queue)
 638     {
 639     }
 640
 641     ~CHIPDoorLockClusterGetUserTypeResponseCallbackBridge() {};
 642
 643     static void CallbackFn(void * context, uint16_t userId, uint8_t userType)
 644     {
 645         CHIPDoorLockClusterGetUserTypeResponseCallbackBridge * callback
 646             = reinterpret_cast<CHIPDoorLockClusterGetUserTypeResponseCallbackBridge *>(context);
 647         if (callback && callback->mQueue) {
 648             dispatch_async(callback->mQueue, ^{
 649                 callback->mHandler(nil, @ {
 650                     @"userId" : [NSNumber numberWithUnsignedShort:userId],
 651                     @"userType" : [NSNumber numberWithUnsignedChar:userType],
 652                 });
 653                 callback->Cancel();
 654                 delete callback;
 655             });
 656         }
 657     };
 658
 659 private:
 660     ResponseHandler mHandler;
 661     dispatch_queue_t mQueue;
 662 };
 663
 664 class CHIPDoorLockClusterGetWeekdayScheduleResponseCallbackBridge
 665     : public Callback::Callback<DoorLockClusterGetWeekdayScheduleResponseCallback> {
 666 public:
 667     CHIPDoorLockClusterGetWeekdayScheduleResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
 668         : Callback::Callback<DoorLockClusterGetWeekdayScheduleResponseCallback>(CallbackFn, this)
 669         , mHandler(handler)
 670         , mQueue(queue)
 671     {
 672     }
 673
 674     ~CHIPDoorLockClusterGetWeekdayScheduleResponseCallbackBridge() {};
 675
 676     static void CallbackFn(void * context, uint8_t scheduleId, uint16_t userId, uint8_t daysMask, uint8_t startHour,
 677         uint8_t startMinute, uint8_t endHour, uint8_t endMinute)
 678     {
 679         CHIPDoorLockClusterGetWeekdayScheduleResponseCallbackBridge * callback
 680             = reinterpret_cast<CHIPDoorLockClusterGetWeekdayScheduleResponseCallbackBridge *>(context);
 681         if (callback && callback->mQueue) {
 682             dispatch_async(callback->mQueue, ^{
 683                 callback->mHandler(nil, @ {
 684                     @"scheduleId" : [NSNumber numberWithUnsignedChar:scheduleId],
 685                     @"userId" : [NSNumber numberWithUnsignedShort:userId],
 686                     @"daysMask" : [NSNumber numberWithUnsignedChar:daysMask],
 687                     @"startHour" : [NSNumber numberWithUnsignedChar:startHour],
 688                     @"startMinute" : [NSNumber numberWithUnsignedChar:startMinute],
 689                     @"endHour" : [NSNumber numberWithUnsignedChar:endHour],
 690                     @"endMinute" : [NSNumber numberWithUnsignedChar:endMinute],
 691                 });
 692                 callback->Cancel();
 693                 delete callback;
 694             });
 695         }
 696     };
 697
 698 private:
 699     ResponseHandler mHandler;
 700     dispatch_queue_t mQueue;
 701 };
 702
 703 class CHIPDoorLockClusterGetYeardayScheduleResponseCallbackBridge
 704     : public Callback::Callback<DoorLockClusterGetYeardayScheduleResponseCallback> {
 705 public:
 706     CHIPDoorLockClusterGetYeardayScheduleResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
 707         : Callback::Callback<DoorLockClusterGetYeardayScheduleResponseCallback>(CallbackFn, this)
 708         , mHandler(handler)
 709         , mQueue(queue)
 710     {
 711     }
 712
 713     ~CHIPDoorLockClusterGetYeardayScheduleResponseCallbackBridge() {};
 714
 715     static void CallbackFn(void * context, uint8_t scheduleId, uint16_t userId, uint32_t localStartTime, uint32_t localEndTime)
 716     {
 717         CHIPDoorLockClusterGetYeardayScheduleResponseCallbackBridge * callback
 718             = reinterpret_cast<CHIPDoorLockClusterGetYeardayScheduleResponseCallbackBridge *>(context);
 719         if (callback && callback->mQueue) {
 720             dispatch_async(callback->mQueue, ^{
 721                 callback->mHandler(nil, @ {
 722                     @"scheduleId" : [NSNumber numberWithUnsignedChar:scheduleId],
 723                     @"userId" : [NSNumber numberWithUnsignedShort:userId],
 724                     @"localStartTime" : [NSNumber numberWithUnsignedLong:localStartTime],
 725                     @"localEndTime" : [NSNumber numberWithUnsignedLong:localEndTime],
 726                 });
 727                 callback->Cancel();
 728                 delete callback;
 729             });
 730         }
 731     };
 732
 733 private:
 734     ResponseHandler mHandler;
 735     dispatch_queue_t mQueue;
 736 };
 737
 738 class CHIPDoorLockClusterLockDoorResponseCallbackBridge : public Callback::Callback<DoorLockClusterLockDoorResponseCallback> {
 739 public:
 740     CHIPDoorLockClusterLockDoorResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
 741         : Callback::Callback<DoorLockClusterLockDoorResponseCallback>(CallbackFn, this)
 742         , mHandler(handler)
 743         , mQueue(queue)
 744     {
 745     }
 746
 747     ~CHIPDoorLockClusterLockDoorResponseCallbackBridge() {};
 748
 749     static void CallbackFn(void * context)
 750     {
 751         CHIPDoorLockClusterLockDoorResponseCallbackBridge * callback
 752             = reinterpret_cast<CHIPDoorLockClusterLockDoorResponseCallbackBridge *>(context);
 753         if (callback && callback->mQueue) {
 754             dispatch_async(callback->mQueue, ^{
 755                 callback->mHandler(nil, @ {});
 756                 callback->Cancel();
 757                 delete callback;
 758             });
 759         }
 760     };
 761
 762 private:
 763     ResponseHandler mHandler;
 764     dispatch_queue_t mQueue;
 765 };
 766
 767 class CHIPDoorLockClusterSetHolidayScheduleResponseCallbackBridge
 768     : public Callback::Callback<DoorLockClusterSetHolidayScheduleResponseCallback> {
 769 public:
 770     CHIPDoorLockClusterSetHolidayScheduleResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
 771         : Callback::Callback<DoorLockClusterSetHolidayScheduleResponseCallback>(CallbackFn, this)
 772         , mHandler(handler)
 773         , mQueue(queue)
 774     {
 775     }
 776
 777     ~CHIPDoorLockClusterSetHolidayScheduleResponseCallbackBridge() {};
 778
 779     static void CallbackFn(void * context)
 780     {
 781         CHIPDoorLockClusterSetHolidayScheduleResponseCallbackBridge * callback
 782             = reinterpret_cast<CHIPDoorLockClusterSetHolidayScheduleResponseCallbackBridge *>(context);
 783         if (callback && callback->mQueue) {
 784             dispatch_async(callback->mQueue, ^{
 785                 callback->mHandler(nil, @ {});
 786                 callback->Cancel();
 787                 delete callback;
 788             });
 789         }
 790     };
 791
 792 private:
 793     ResponseHandler mHandler;
 794     dispatch_queue_t mQueue;
 795 };
 796
 797 class CHIPDoorLockClusterSetPinResponseCallbackBridge : public Callback::Callback<DoorLockClusterSetPinResponseCallback> {
 798 public:
 799     CHIPDoorLockClusterSetPinResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
 800         : Callback::Callback<DoorLockClusterSetPinResponseCallback>(CallbackFn, this)
 801         , mHandler(handler)
 802         , mQueue(queue)
 803     {
 804     }
 805
 806     ~CHIPDoorLockClusterSetPinResponseCallbackBridge() {};
 807
 808     static void CallbackFn(void * context)
 809     {
 810         CHIPDoorLockClusterSetPinResponseCallbackBridge * callback
 811             = reinterpret_cast<CHIPDoorLockClusterSetPinResponseCallbackBridge *>(context);
 812         if (callback && callback->mQueue) {
 813             dispatch_async(callback->mQueue, ^{
 814                 callback->mHandler(nil, @ {});
 815                 callback->Cancel();
 816                 delete callback;
 817             });
 818         }
 819     };
 820
 821 private:
 822     ResponseHandler mHandler;
 823     dispatch_queue_t mQueue;
 824 };
 825
 826 class CHIPDoorLockClusterSetRfidResponseCallbackBridge : public Callback::Callback<DoorLockClusterSetRfidResponseCallback> {
 827 public:
 828     CHIPDoorLockClusterSetRfidResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
 829         : Callback::Callback<DoorLockClusterSetRfidResponseCallback>(CallbackFn, this)
 830         , mHandler(handler)
 831         , mQueue(queue)
 832     {
 833     }
 834
 835     ~CHIPDoorLockClusterSetRfidResponseCallbackBridge() {};
 836
 837     static void CallbackFn(void * context)
 838     {
 839         CHIPDoorLockClusterSetRfidResponseCallbackBridge * callback
 840             = reinterpret_cast<CHIPDoorLockClusterSetRfidResponseCallbackBridge *>(context);
 841         if (callback && callback->mQueue) {
 842             dispatch_async(callback->mQueue, ^{
 843                 callback->mHandler(nil, @ {});
 844                 callback->Cancel();
 845                 delete callback;
 846             });
 847         }
 848     };
 849
 850 private:
 851     ResponseHandler mHandler;
 852     dispatch_queue_t mQueue;
 853 };
 854
 855 class CHIPDoorLockClusterSetUserTypeResponseCallbackBridge : public Callback::Callback<DoorLockClusterSetUserTypeResponseCallback> {
 856 public:
 857     CHIPDoorLockClusterSetUserTypeResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
 858         : Callback::Callback<DoorLockClusterSetUserTypeResponseCallback>(CallbackFn, this)
 859         , mHandler(handler)
 860         , mQueue(queue)
 861     {
 862     }
 863
 864     ~CHIPDoorLockClusterSetUserTypeResponseCallbackBridge() {};
 865
 866     static void CallbackFn(void * context)
 867     {
 868         CHIPDoorLockClusterSetUserTypeResponseCallbackBridge * callback
 869             = reinterpret_cast<CHIPDoorLockClusterSetUserTypeResponseCallbackBridge *>(context);
 870         if (callback && callback->mQueue) {
 871             dispatch_async(callback->mQueue, ^{
 872                 callback->mHandler(nil, @ {});
 873                 callback->Cancel();
 874                 delete callback;
 875             });
 876         }
 877     };
 878
 879 private:
 880     ResponseHandler mHandler;
 881     dispatch_queue_t mQueue;
 882 };
 883
 884 class CHIPDoorLockClusterSetWeekdayScheduleResponseCallbackBridge
 885     : public Callback::Callback<DoorLockClusterSetWeekdayScheduleResponseCallback> {
 886 public:
 887     CHIPDoorLockClusterSetWeekdayScheduleResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
 888         : Callback::Callback<DoorLockClusterSetWeekdayScheduleResponseCallback>(CallbackFn, this)
 889         , mHandler(handler)
 890         , mQueue(queue)
 891     {
 892     }
 893
 894     ~CHIPDoorLockClusterSetWeekdayScheduleResponseCallbackBridge() {};
 895
 896     static void CallbackFn(void * context)
 897     {
 898         CHIPDoorLockClusterSetWeekdayScheduleResponseCallbackBridge * callback
 899             = reinterpret_cast<CHIPDoorLockClusterSetWeekdayScheduleResponseCallbackBridge *>(context);
 900         if (callback && callback->mQueue) {
 901             dispatch_async(callback->mQueue, ^{
 902                 callback->mHandler(nil, @ {});
 903                 callback->Cancel();
 904                 delete callback;
 905             });
 906         }
 907     };
 908
 909 private:
 910     ResponseHandler mHandler;
 911     dispatch_queue_t mQueue;
 912 };
 913
 914 class CHIPDoorLockClusterSetYeardayScheduleResponseCallbackBridge
 915     : public Callback::Callback<DoorLockClusterSetYeardayScheduleResponseCallback> {
 916 public:
 917     CHIPDoorLockClusterSetYeardayScheduleResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
 918         : Callback::Callback<DoorLockClusterSetYeardayScheduleResponseCallback>(CallbackFn, this)
 919         , mHandler(handler)
 920         , mQueue(queue)
 921     {
 922     }
 923
 924     ~CHIPDoorLockClusterSetYeardayScheduleResponseCallbackBridge() {};
 925
 926     static void CallbackFn(void * context)
 927     {
 928         CHIPDoorLockClusterSetYeardayScheduleResponseCallbackBridge * callback
 929             = reinterpret_cast<CHIPDoorLockClusterSetYeardayScheduleResponseCallbackBridge *>(context);
 930         if (callback && callback->mQueue) {
 931             dispatch_async(callback->mQueue, ^{
 932                 callback->mHandler(nil, @ {});
 933                 callback->Cancel();
 934                 delete callback;
 935             });
 936         }
 937     };
 938
 939 private:
 940     ResponseHandler mHandler;
 941     dispatch_queue_t mQueue;
 942 };
 943
 944 class CHIPDoorLockClusterUnlockDoorResponseCallbackBridge : public Callback::Callback<DoorLockClusterUnlockDoorResponseCallback> {
 945 public:
 946     CHIPDoorLockClusterUnlockDoorResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
 947         : Callback::Callback<DoorLockClusterUnlockDoorResponseCallback>(CallbackFn, this)
 948         , mHandler(handler)
 949         , mQueue(queue)
 950     {
 951     }
 952
 953     ~CHIPDoorLockClusterUnlockDoorResponseCallbackBridge() {};
 954
 955     static void CallbackFn(void * context)
 956     {
 957         CHIPDoorLockClusterUnlockDoorResponseCallbackBridge * callback
 958             = reinterpret_cast<CHIPDoorLockClusterUnlockDoorResponseCallbackBridge *>(context);
 959         if (callback && callback->mQueue) {
 960             dispatch_async(callback->mQueue, ^{
 961                 callback->mHandler(nil, @ {});
 962                 callback->Cancel();
 963                 delete callback;
 964             });
 965         }
 966     };
 967
 968 private:
 969     ResponseHandler mHandler;
 970     dispatch_queue_t mQueue;
 971 };
 972
 973 class CHIPDoorLockClusterUnlockWithTimeoutResponseCallbackBridge
 974     : public Callback::Callback<DoorLockClusterUnlockWithTimeoutResponseCallback> {
 975 public:
 976     CHIPDoorLockClusterUnlockWithTimeoutResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
 977         : Callback::Callback<DoorLockClusterUnlockWithTimeoutResponseCallback>(CallbackFn, this)
 978         , mHandler(handler)
 979         , mQueue(queue)
 980     {
 981     }
 982
 983     ~CHIPDoorLockClusterUnlockWithTimeoutResponseCallbackBridge() {};
 984
 985     static void CallbackFn(void * context)
 986     {
 987         CHIPDoorLockClusterUnlockWithTimeoutResponseCallbackBridge * callback
 988             = reinterpret_cast<CHIPDoorLockClusterUnlockWithTimeoutResponseCallbackBridge *>(context);
 989         if (callback && callback->mQueue) {
 990             dispatch_async(callback->mQueue, ^{
 991                 callback->mHandler(nil, @ {});
 992                 callback->Cancel();
 993                 delete callback;
 994             });
 995         }
 996     };
 997
 998 private:
 999     ResponseHandler mHandler;
1000     dispatch_queue_t mQueue;
1001 };
1002
1003 class CHIPGroupsClusterAddGroupResponseCallbackBridge : public Callback::Callback<GroupsClusterAddGroupResponseCallback> {
1004 public:
1005     CHIPGroupsClusterAddGroupResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
1006         : Callback::Callback<GroupsClusterAddGroupResponseCallback>(CallbackFn, this)
1007         , mHandler(handler)
1008         , mQueue(queue)
1009     {
1010     }
1011
1012     ~CHIPGroupsClusterAddGroupResponseCallbackBridge() {};
1013
1014     static void CallbackFn(void * context, uint16_t groupId)
1015     {
1016         CHIPGroupsClusterAddGroupResponseCallbackBridge * callback
1017             = reinterpret_cast<CHIPGroupsClusterAddGroupResponseCallbackBridge *>(context);
1018         if (callback && callback->mQueue) {
1019             dispatch_async(callback->mQueue, ^{
1020                 callback->mHandler(nil, @ {
1021                     @"groupId" : [NSNumber numberWithUnsignedShort:groupId],
1022                 });
1023                 callback->Cancel();
1024                 delete callback;
1025             });
1026         }
1027     };
1028
1029 private:
1030     ResponseHandler mHandler;
1031     dispatch_queue_t mQueue;
1032 };
1033
1034 class CHIPGroupsClusterGetGroupMembershipResponseCallbackBridge
1035     : public Callback::Callback<GroupsClusterGetGroupMembershipResponseCallback> {
1036 public:
1037     CHIPGroupsClusterGetGroupMembershipResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
1038         : Callback::Callback<GroupsClusterGetGroupMembershipResponseCallback>(CallbackFn, this)
1039         , mHandler(handler)
1040         , mQueue(queue)
1041     {
1042     }
1043
1044     ~CHIPGroupsClusterGetGroupMembershipResponseCallbackBridge() {};
1045
1046     static void CallbackFn(
1047         void * context, uint8_t capacity, uint8_t groupCount, /* TYPE WARNING: array array defaults to */ uint8_t * groupList)
1048     {
1049         CHIPGroupsClusterGetGroupMembershipResponseCallbackBridge * callback
1050             = reinterpret_cast<CHIPGroupsClusterGetGroupMembershipResponseCallbackBridge *>(context);
1051         if (callback && callback->mQueue) {
1052             dispatch_async(callback->mQueue, ^{
1053                 callback->mHandler(nil, @ {
1054                     @"capacity" : [NSNumber numberWithUnsignedChar:capacity],
1055                     @"groupCount" : [NSNumber numberWithUnsignedChar:groupCount],
1056                     // groupList: /* TYPE WARNING: array array defaults to */ uint8_t *
1057                     // Conversion from this type to Objc is not properly implemented yet
1058                 });
1059                 callback->Cancel();
1060                 delete callback;
1061             });
1062         }
1063     };
1064
1065 private:
1066     ResponseHandler mHandler;
1067     dispatch_queue_t mQueue;
1068 };
1069
1070 class CHIPGroupsClusterRemoveGroupResponseCallbackBridge : public Callback::Callback<GroupsClusterRemoveGroupResponseCallback> {
1071 public:
1072     CHIPGroupsClusterRemoveGroupResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
1073         : Callback::Callback<GroupsClusterRemoveGroupResponseCallback>(CallbackFn, this)
1074         , mHandler(handler)
1075         , mQueue(queue)
1076     {
1077     }
1078
1079     ~CHIPGroupsClusterRemoveGroupResponseCallbackBridge() {};
1080
1081     static void CallbackFn(void * context, uint16_t groupId)
1082     {
1083         CHIPGroupsClusterRemoveGroupResponseCallbackBridge * callback
1084             = reinterpret_cast<CHIPGroupsClusterRemoveGroupResponseCallbackBridge *>(context);
1085         if (callback && callback->mQueue) {
1086             dispatch_async(callback->mQueue, ^{
1087                 callback->mHandler(nil, @ {
1088                     @"groupId" : [NSNumber numberWithUnsignedShort:groupId],
1089                 });
1090                 callback->Cancel();
1091                 delete callback;
1092             });
1093         }
1094     };
1095
1096 private:
1097     ResponseHandler mHandler;
1098     dispatch_queue_t mQueue;
1099 };
1100
1101 class CHIPGroupsClusterViewGroupResponseCallbackBridge : public Callback::Callback<GroupsClusterViewGroupResponseCallback> {
1102 public:
1103     CHIPGroupsClusterViewGroupResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
1104         : Callback::Callback<GroupsClusterViewGroupResponseCallback>(CallbackFn, this)
1105         , mHandler(handler)
1106         , mQueue(queue)
1107     {
1108     }
1109
1110     ~CHIPGroupsClusterViewGroupResponseCallbackBridge() {};
1111
1112     static void CallbackFn(void * context, uint16_t groupId, uint8_t * groupName)
1113     {
1114         CHIPGroupsClusterViewGroupResponseCallbackBridge * callback
1115             = reinterpret_cast<CHIPGroupsClusterViewGroupResponseCallbackBridge *>(context);
1116         if (callback && callback->mQueue) {
1117             dispatch_async(callback->mQueue, ^{
1118                 callback->mHandler(nil, @ {
1119                     @"groupId" : [NSNumber numberWithUnsignedShort:groupId],
1120                     @"groupName" : [NSString stringWithFormat:@"%s", groupName],
1121                 });
1122                 callback->Cancel();
1123                 delete callback;
1124             });
1125         }
1126     };
1127
1128 private:
1129     ResponseHandler mHandler;
1130     dispatch_queue_t mQueue;
1131 };
1132
1133 class CHIPIdentifyClusterIdentifyQueryResponseCallbackBridge
1134     : public Callback::Callback<IdentifyClusterIdentifyQueryResponseCallback> {
1135 public:
1136     CHIPIdentifyClusterIdentifyQueryResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
1137         : Callback::Callback<IdentifyClusterIdentifyQueryResponseCallback>(CallbackFn, this)
1138         , mHandler(handler)
1139         , mQueue(queue)
1140     {
1141     }
1142
1143     ~CHIPIdentifyClusterIdentifyQueryResponseCallbackBridge() {};
1144
1145     static void CallbackFn(void * context, uint16_t timeout)
1146     {
1147         CHIPIdentifyClusterIdentifyQueryResponseCallbackBridge * callback
1148             = reinterpret_cast<CHIPIdentifyClusterIdentifyQueryResponseCallbackBridge *>(context);
1149         if (callback && callback->mQueue) {
1150             dispatch_async(callback->mQueue, ^{
1151                 callback->mHandler(nil, @ {
1152                     @"timeout" : [NSNumber numberWithUnsignedShort:timeout],
1153                 });
1154                 callback->Cancel();
1155                 delete callback;
1156             });
1157         }
1158     };
1159
1160 private:
1161     ResponseHandler mHandler;
1162     dispatch_queue_t mQueue;
1163 };
1164
1165 class CHIPScenesClusterAddSceneResponseCallbackBridge : public Callback::Callback<ScenesClusterAddSceneResponseCallback> {
1166 public:
1167     CHIPScenesClusterAddSceneResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
1168         : Callback::Callback<ScenesClusterAddSceneResponseCallback>(CallbackFn, this)
1169         , mHandler(handler)
1170         , mQueue(queue)
1171     {
1172     }
1173
1174     ~CHIPScenesClusterAddSceneResponseCallbackBridge() {};
1175
1176     static void CallbackFn(void * context, uint16_t groupId, uint8_t sceneId)
1177     {
1178         CHIPScenesClusterAddSceneResponseCallbackBridge * callback
1179             = reinterpret_cast<CHIPScenesClusterAddSceneResponseCallbackBridge *>(context);
1180         if (callback && callback->mQueue) {
1181             dispatch_async(callback->mQueue, ^{
1182                 callback->mHandler(nil, @ {
1183                     @"groupId" : [NSNumber numberWithUnsignedShort:groupId],
1184                     @"sceneId" : [NSNumber numberWithUnsignedChar:sceneId],
1185                 });
1186                 callback->Cancel();
1187                 delete callback;
1188             });
1189         }
1190     };
1191
1192 private:
1193     ResponseHandler mHandler;
1194     dispatch_queue_t mQueue;
1195 };
1196
1197 class CHIPScenesClusterGetSceneMembershipResponseCallbackBridge
1198     : public Callback::Callback<ScenesClusterGetSceneMembershipResponseCallback> {
1199 public:
1200     CHIPScenesClusterGetSceneMembershipResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
1201         : Callback::Callback<ScenesClusterGetSceneMembershipResponseCallback>(CallbackFn, this)
1202         , mHandler(handler)
1203         , mQueue(queue)
1204     {
1205     }
1206
1207     ~CHIPScenesClusterGetSceneMembershipResponseCallbackBridge() {};
1208
1209     static void CallbackFn(void * context, uint8_t capacity, uint16_t groupId, uint8_t sceneCount,
1210         /* TYPE WARNING: array array defaults to */ uint8_t * sceneList)
1211     {
1212         CHIPScenesClusterGetSceneMembershipResponseCallbackBridge * callback
1213             = reinterpret_cast<CHIPScenesClusterGetSceneMembershipResponseCallbackBridge *>(context);
1214         if (callback && callback->mQueue) {
1215             dispatch_async(callback->mQueue, ^{
1216                 callback->mHandler(nil, @ {
1217                     @"capacity" : [NSNumber numberWithUnsignedChar:capacity],
1218                     @"groupId" : [NSNumber numberWithUnsignedShort:groupId],
1219                     @"sceneCount" : [NSNumber numberWithUnsignedChar:sceneCount],
1220                     // sceneList: /* TYPE WARNING: array array defaults to */ uint8_t *
1221                     // Conversion from this type to Objc is not properly implemented yet
1222                 });
1223                 callback->Cancel();
1224                 delete callback;
1225             });
1226         }
1227     };
1228
1229 private:
1230     ResponseHandler mHandler;
1231     dispatch_queue_t mQueue;
1232 };
1233
1234 class CHIPScenesClusterRemoveAllScenesResponseCallbackBridge
1235     : public Callback::Callback<ScenesClusterRemoveAllScenesResponseCallback> {
1236 public:
1237     CHIPScenesClusterRemoveAllScenesResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
1238         : Callback::Callback<ScenesClusterRemoveAllScenesResponseCallback>(CallbackFn, this)
1239         , mHandler(handler)
1240         , mQueue(queue)
1241     {
1242     }
1243
1244     ~CHIPScenesClusterRemoveAllScenesResponseCallbackBridge() {};
1245
1246     static void CallbackFn(void * context, uint16_t groupId)
1247     {
1248         CHIPScenesClusterRemoveAllScenesResponseCallbackBridge * callback
1249             = reinterpret_cast<CHIPScenesClusterRemoveAllScenesResponseCallbackBridge *>(context);
1250         if (callback && callback->mQueue) {
1251             dispatch_async(callback->mQueue, ^{
1252                 callback->mHandler(nil, @ {
1253                     @"groupId" : [NSNumber numberWithUnsignedShort:groupId],
1254                 });
1255                 callback->Cancel();
1256                 delete callback;
1257             });
1258         }
1259     };
1260
1261 private:
1262     ResponseHandler mHandler;
1263     dispatch_queue_t mQueue;
1264 };
1265
1266 class CHIPScenesClusterRemoveSceneResponseCallbackBridge : public Callback::Callback<ScenesClusterRemoveSceneResponseCallback> {
1267 public:
1268     CHIPScenesClusterRemoveSceneResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
1269         : Callback::Callback<ScenesClusterRemoveSceneResponseCallback>(CallbackFn, this)
1270         , mHandler(handler)
1271         , mQueue(queue)
1272     {
1273     }
1274
1275     ~CHIPScenesClusterRemoveSceneResponseCallbackBridge() {};
1276
1277     static void CallbackFn(void * context, uint16_t groupId, uint8_t sceneId)
1278     {
1279         CHIPScenesClusterRemoveSceneResponseCallbackBridge * callback
1280             = reinterpret_cast<CHIPScenesClusterRemoveSceneResponseCallbackBridge *>(context);
1281         if (callback && callback->mQueue) {
1282             dispatch_async(callback->mQueue, ^{
1283                 callback->mHandler(nil, @ {
1284                     @"groupId" : [NSNumber numberWithUnsignedShort:groupId],
1285                     @"sceneId" : [NSNumber numberWithUnsignedChar:sceneId],
1286                 });
1287                 callback->Cancel();
1288                 delete callback;
1289             });
1290         }
1291     };
1292
1293 private:
1294     ResponseHandler mHandler;
1295     dispatch_queue_t mQueue;
1296 };
1297
1298 class CHIPScenesClusterStoreSceneResponseCallbackBridge : public Callback::Callback<ScenesClusterStoreSceneResponseCallback> {
1299 public:
1300     CHIPScenesClusterStoreSceneResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
1301         : Callback::Callback<ScenesClusterStoreSceneResponseCallback>(CallbackFn, this)
1302         , mHandler(handler)
1303         , mQueue(queue)
1304     {
1305     }
1306
1307     ~CHIPScenesClusterStoreSceneResponseCallbackBridge() {};
1308
1309     static void CallbackFn(void * context, uint16_t groupId, uint8_t sceneId)
1310     {
1311         CHIPScenesClusterStoreSceneResponseCallbackBridge * callback
1312             = reinterpret_cast<CHIPScenesClusterStoreSceneResponseCallbackBridge *>(context);
1313         if (callback && callback->mQueue) {
1314             dispatch_async(callback->mQueue, ^{
1315                 callback->mHandler(nil, @ {
1316                     @"groupId" : [NSNumber numberWithUnsignedShort:groupId],
1317                     @"sceneId" : [NSNumber numberWithUnsignedChar:sceneId],
1318                 });
1319                 callback->Cancel();
1320                 delete callback;
1321             });
1322         }
1323     };
1324
1325 private:
1326     ResponseHandler mHandler;
1327     dispatch_queue_t mQueue;
1328 };
1329
1330 class CHIPScenesClusterViewSceneResponseCallbackBridge : public Callback::Callback<ScenesClusterViewSceneResponseCallback> {
1331 public:
1332     CHIPScenesClusterViewSceneResponseCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
1333         : Callback::Callback<ScenesClusterViewSceneResponseCallback>(CallbackFn, this)
1334         , mHandler(handler)
1335         , mQueue(queue)
1336     {
1337     }
1338
1339     ~CHIPScenesClusterViewSceneResponseCallbackBridge() {};
1340
1341     static void CallbackFn(void * context, uint16_t groupId, uint8_t sceneId, uint16_t transitionTime, uint8_t * sceneName,
1342         /* TYPE WARNING: array array defaults to */ uint8_t * extensionFieldSets)
1343     {
1344         CHIPScenesClusterViewSceneResponseCallbackBridge * callback
1345             = reinterpret_cast<CHIPScenesClusterViewSceneResponseCallbackBridge *>(context);
1346         if (callback && callback->mQueue) {
1347             dispatch_async(callback->mQueue, ^{
1348                 callback->mHandler(nil, @ {
1349                     @"groupId" : [NSNumber numberWithUnsignedShort:groupId],
1350                     @"sceneId" : [NSNumber numberWithUnsignedChar:sceneId],
1351                     @"transitionTime" : [NSNumber numberWithUnsignedShort:transitionTime],
1352                     @"sceneName" : [NSString stringWithFormat:@"%s", sceneName],
1353                     // extensionFieldSets: /* TYPE WARNING: array array defaults to */ uint8_t *
1354                     // Conversion from this type to Objc is not properly implemented yet
1355                 });
1356                 callback->Cancel();
1357                 delete callback;
1358             });
1359         }
1360     };
1361
1362 private:
1363     ResponseHandler mHandler;
1364     dispatch_queue_t mQueue;
1365 };
1366
1367 @interface CHIPCluster ()
1368 @property (readonly, nonatomic) dispatch_queue_t callbackQueue;
1369 - (Controller::ClusterBase *)getCluster;
1370 @end
1371
1372 @implementation CHIPCluster
1373 - (instancetype)initWithDevice:(CHIPDevice *)device endpoint:(EndpointId)endpoint queue:(dispatch_queue_t)queue
1374 {
1375     if (self = [super init]) {
1376         Controller::ClusterBase * cppCluster = [self getCluster];
1377         if (cppCluster == nullptr) {
1378             return nil;
1379         }
1380
1381         CHIP_ERROR err = cppCluster->Associate([device internalDevice], endpoint);
1382         if (err != CHIP_NO_ERROR) {
1383             return nil;
1384         }
1385
1386         _callbackQueue = queue;
1387     }
1388     return self;
1389 }
1390
1391 - (Controller::ClusterBase *)getCluster
1392 {
1393     return nullptr;
1394 }
1395 @end
1396
1397 @interface CHIPBarrierControl ()
1398 @property (readonly) Controller::BarrierControlCluster cppCluster;
1399 @end
1400
1401 @implementation CHIPBarrierControl
1402
1403 - (Controller::ClusterBase *)getCluster
1404 {
1405     return &_cppCluster;
1406 }
1407
1408 - (void)barrierControlGoToPercent:(uint8_t)percentOpen completionHandler:(ResponseHandler)completionHandler
1409 {
1410     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1411     if (!onSuccess) {
1412         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1413         return;
1414     }
1415
1416     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1417     if (!onFailure) {
1418         delete onSuccess;
1419         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1420         return;
1421     }
1422
1423     CHIP_ERROR err = self.cppCluster.BarrierControlGoToPercent(onSuccess->Cancel(), onFailure->Cancel(), percentOpen);
1424     if (err != CHIP_NO_ERROR) {
1425         delete onSuccess;
1426         delete onFailure;
1427         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1428     }
1429 }
1430 - (void)barrierControlStop:(ResponseHandler)completionHandler
1431 {
1432     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1433     if (!onSuccess) {
1434         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1435         return;
1436     }
1437
1438     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1439     if (!onFailure) {
1440         delete onSuccess;
1441         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1442         return;
1443     }
1444
1445     CHIP_ERROR err = self.cppCluster.BarrierControlStop(onSuccess->Cancel(), onFailure->Cancel());
1446     if (err != CHIP_NO_ERROR) {
1447         delete onSuccess;
1448         delete onFailure;
1449         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1450     }
1451 }
1452
1453 - (void)readAttributeBarrierMovingState:(ResponseHandler)completionHandler
1454 {
1455     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1456     if (!onSuccess) {
1457         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1458         return;
1459     }
1460
1461     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1462     if (!onFailure) {
1463         delete onSuccess;
1464         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1465         return;
1466     }
1467
1468     CHIP_ERROR err = self.cppCluster.ReadAttributeBarrierMovingState(onSuccess->Cancel(), onFailure->Cancel());
1469     if (err != CHIP_NO_ERROR) {
1470         delete onSuccess;
1471         delete onFailure;
1472         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1473     }
1474 }
1475
1476 - (void)readAttributeBarrierSafetyStatus:(ResponseHandler)completionHandler
1477 {
1478     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1479     if (!onSuccess) {
1480         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1481         return;
1482     }
1483
1484     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1485     if (!onFailure) {
1486         delete onSuccess;
1487         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1488         return;
1489     }
1490
1491     CHIP_ERROR err = self.cppCluster.ReadAttributeBarrierSafetyStatus(onSuccess->Cancel(), onFailure->Cancel());
1492     if (err != CHIP_NO_ERROR) {
1493         delete onSuccess;
1494         delete onFailure;
1495         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1496     }
1497 }
1498
1499 - (void)readAttributeBarrierCapabilities:(ResponseHandler)completionHandler
1500 {
1501     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1502     if (!onSuccess) {
1503         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1504         return;
1505     }
1506
1507     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1508     if (!onFailure) {
1509         delete onSuccess;
1510         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1511         return;
1512     }
1513
1514     CHIP_ERROR err = self.cppCluster.ReadAttributeBarrierCapabilities(onSuccess->Cancel(), onFailure->Cancel());
1515     if (err != CHIP_NO_ERROR) {
1516         delete onSuccess;
1517         delete onFailure;
1518         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1519     }
1520 }
1521
1522 - (void)readAttributeBarrierPosition:(ResponseHandler)completionHandler
1523 {
1524     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1525     if (!onSuccess) {
1526         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1527         return;
1528     }
1529
1530     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1531     if (!onFailure) {
1532         delete onSuccess;
1533         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1534         return;
1535     }
1536
1537     CHIP_ERROR err = self.cppCluster.ReadAttributeBarrierPosition(onSuccess->Cancel(), onFailure->Cancel());
1538     if (err != CHIP_NO_ERROR) {
1539         delete onSuccess;
1540         delete onFailure;
1541         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1542     }
1543 }
1544
1545 - (void)readAttributeClusterRevision:(ResponseHandler)completionHandler
1546 {
1547     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1548     if (!onSuccess) {
1549         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1550         return;
1551     }
1552
1553     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1554     if (!onFailure) {
1555         delete onSuccess;
1556         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1557         return;
1558     }
1559
1560     CHIP_ERROR err = self.cppCluster.ReadAttributeClusterRevision(onSuccess->Cancel(), onFailure->Cancel());
1561     if (err != CHIP_NO_ERROR) {
1562         delete onSuccess;
1563         delete onFailure;
1564         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1565     }
1566 }
1567
1568 @end
1569
1570 @interface CHIPBasic ()
1571 @property (readonly) Controller::BasicCluster cppCluster;
1572 @end
1573
1574 @implementation CHIPBasic
1575
1576 - (Controller::ClusterBase *)getCluster
1577 {
1578     return &_cppCluster;
1579 }
1580
1581 - (void)mfgSpecificPing:(ResponseHandler)completionHandler
1582 {
1583     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1584     if (!onSuccess) {
1585         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1586         return;
1587     }
1588
1589     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1590     if (!onFailure) {
1591         delete onSuccess;
1592         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1593         return;
1594     }
1595
1596     CHIP_ERROR err = self.cppCluster.MfgSpecificPing(onSuccess->Cancel(), onFailure->Cancel());
1597     if (err != CHIP_NO_ERROR) {
1598         delete onSuccess;
1599         delete onFailure;
1600         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1601     }
1602 }
1603 - (void)resetToFactoryDefaults:(ResponseHandler)completionHandler
1604 {
1605     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1606     if (!onSuccess) {
1607         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1608         return;
1609     }
1610
1611     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1612     if (!onFailure) {
1613         delete onSuccess;
1614         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1615         return;
1616     }
1617
1618     CHIP_ERROR err = self.cppCluster.ResetToFactoryDefaults(onSuccess->Cancel(), onFailure->Cancel());
1619     if (err != CHIP_NO_ERROR) {
1620         delete onSuccess;
1621         delete onFailure;
1622         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1623     }
1624 }
1625
1626 - (void)readAttributeZclVersion:(ResponseHandler)completionHandler
1627 {
1628     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1629     if (!onSuccess) {
1630         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1631         return;
1632     }
1633
1634     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1635     if (!onFailure) {
1636         delete onSuccess;
1637         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1638         return;
1639     }
1640
1641     CHIP_ERROR err = self.cppCluster.ReadAttributeZclVersion(onSuccess->Cancel(), onFailure->Cancel());
1642     if (err != CHIP_NO_ERROR) {
1643         delete onSuccess;
1644         delete onFailure;
1645         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1646     }
1647 }
1648
1649 - (void)readAttributePowerSource:(ResponseHandler)completionHandler
1650 {
1651     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1652     if (!onSuccess) {
1653         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1654         return;
1655     }
1656
1657     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1658     if (!onFailure) {
1659         delete onSuccess;
1660         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1661         return;
1662     }
1663
1664     CHIP_ERROR err = self.cppCluster.ReadAttributePowerSource(onSuccess->Cancel(), onFailure->Cancel());
1665     if (err != CHIP_NO_ERROR) {
1666         delete onSuccess;
1667         delete onFailure;
1668         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1669     }
1670 }
1671
1672 - (void)readAttributeClusterRevision:(ResponseHandler)completionHandler
1673 {
1674     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1675     if (!onSuccess) {
1676         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1677         return;
1678     }
1679
1680     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1681     if (!onFailure) {
1682         delete onSuccess;
1683         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1684         return;
1685     }
1686
1687     CHIP_ERROR err = self.cppCluster.ReadAttributeClusterRevision(onSuccess->Cancel(), onFailure->Cancel());
1688     if (err != CHIP_NO_ERROR) {
1689         delete onSuccess;
1690         delete onFailure;
1691         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1692     }
1693 }
1694
1695 @end
1696
1697 @interface CHIPBinding ()
1698 @property (readonly) Controller::BindingCluster cppCluster;
1699 @end
1700
1701 @implementation CHIPBinding
1702
1703 - (Controller::ClusterBase *)getCluster
1704 {
1705     return &_cppCluster;
1706 }
1707
1708 - (void)bind:(uint64_t)nodeId
1709               groupId:(uint16_t)groupId
1710            endpointId:(uint8_t)endpointId
1711             clusterId:(uint16_t)clusterId
1712     completionHandler:(ResponseHandler)completionHandler
1713 {
1714     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1715     if (!onSuccess) {
1716         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1717         return;
1718     }
1719
1720     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1721     if (!onFailure) {
1722         delete onSuccess;
1723         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1724         return;
1725     }
1726
1727     CHIP_ERROR err = self.cppCluster.Bind(onSuccess->Cancel(), onFailure->Cancel(), nodeId, groupId, endpointId, clusterId);
1728     if (err != CHIP_NO_ERROR) {
1729         delete onSuccess;
1730         delete onFailure;
1731         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1732     }
1733 }
1734 - (void)unbind:(uint64_t)nodeId
1735               groupId:(uint16_t)groupId
1736            endpointId:(uint8_t)endpointId
1737             clusterId:(uint16_t)clusterId
1738     completionHandler:(ResponseHandler)completionHandler
1739 {
1740     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1741     if (!onSuccess) {
1742         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1743         return;
1744     }
1745
1746     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1747     if (!onFailure) {
1748         delete onSuccess;
1749         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1750         return;
1751     }
1752
1753     CHIP_ERROR err = self.cppCluster.Unbind(onSuccess->Cancel(), onFailure->Cancel(), nodeId, groupId, endpointId, clusterId);
1754     if (err != CHIP_NO_ERROR) {
1755         delete onSuccess;
1756         delete onFailure;
1757         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1758     }
1759 }
1760
1761 - (void)readAttributeClusterRevision:(ResponseHandler)completionHandler
1762 {
1763     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1764     if (!onSuccess) {
1765         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1766         return;
1767     }
1768
1769     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1770     if (!onFailure) {
1771         delete onSuccess;
1772         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1773         return;
1774     }
1775
1776     CHIP_ERROR err = self.cppCluster.ReadAttributeClusterRevision(onSuccess->Cancel(), onFailure->Cancel());
1777     if (err != CHIP_NO_ERROR) {
1778         delete onSuccess;
1779         delete onFailure;
1780         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1781     }
1782 }
1783
1784 @end
1785
1786 @interface CHIPColorControl ()
1787 @property (readonly) Controller::ColorControlCluster cppCluster;
1788 @end
1789
1790 @implementation CHIPColorControl
1791
1792 - (Controller::ClusterBase *)getCluster
1793 {
1794     return &_cppCluster;
1795 }
1796
1797 - (void)moveColor:(int16_t)rateX
1798                 rateY:(int16_t)rateY
1799           optionsMask:(uint8_t)optionsMask
1800       optionsOverride:(uint8_t)optionsOverride
1801     completionHandler:(ResponseHandler)completionHandler
1802 {
1803     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1804     if (!onSuccess) {
1805         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1806         return;
1807     }
1808
1809     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1810     if (!onFailure) {
1811         delete onSuccess;
1812         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1813         return;
1814     }
1815
1816     CHIP_ERROR err
1817         = self.cppCluster.MoveColor(onSuccess->Cancel(), onFailure->Cancel(), rateX, rateY, optionsMask, optionsOverride);
1818     if (err != CHIP_NO_ERROR) {
1819         delete onSuccess;
1820         delete onFailure;
1821         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1822     }
1823 }
1824 - (void)moveColorTemperature:(uint8_t)moveMode
1825                         rate:(uint16_t)rate
1826      colorTemperatureMinimum:(uint16_t)colorTemperatureMinimum
1827      colorTemperatureMaximum:(uint16_t)colorTemperatureMaximum
1828                  optionsMask:(uint8_t)optionsMask
1829              optionsOverride:(uint8_t)optionsOverride
1830            completionHandler:(ResponseHandler)completionHandler
1831 {
1832     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1833     if (!onSuccess) {
1834         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1835         return;
1836     }
1837
1838     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1839     if (!onFailure) {
1840         delete onSuccess;
1841         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1842         return;
1843     }
1844
1845     CHIP_ERROR err = self.cppCluster.MoveColorTemperature(onSuccess->Cancel(), onFailure->Cancel(), moveMode, rate,
1846         colorTemperatureMinimum, colorTemperatureMaximum, optionsMask, optionsOverride);
1847     if (err != CHIP_NO_ERROR) {
1848         delete onSuccess;
1849         delete onFailure;
1850         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1851     }
1852 }
1853 - (void)moveHue:(uint8_t)moveMode
1854                  rate:(uint8_t)rate
1855           optionsMask:(uint8_t)optionsMask
1856       optionsOverride:(uint8_t)optionsOverride
1857     completionHandler:(ResponseHandler)completionHandler
1858 {
1859     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1860     if (!onSuccess) {
1861         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1862         return;
1863     }
1864
1865     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1866     if (!onFailure) {
1867         delete onSuccess;
1868         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1869         return;
1870     }
1871
1872     CHIP_ERROR err
1873         = self.cppCluster.MoveHue(onSuccess->Cancel(), onFailure->Cancel(), moveMode, rate, optionsMask, optionsOverride);
1874     if (err != CHIP_NO_ERROR) {
1875         delete onSuccess;
1876         delete onFailure;
1877         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1878     }
1879 }
1880 - (void)moveSaturation:(uint8_t)moveMode
1881                   rate:(uint8_t)rate
1882            optionsMask:(uint8_t)optionsMask
1883        optionsOverride:(uint8_t)optionsOverride
1884      completionHandler:(ResponseHandler)completionHandler
1885 {
1886     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1887     if (!onSuccess) {
1888         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1889         return;
1890     }
1891
1892     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1893     if (!onFailure) {
1894         delete onSuccess;
1895         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1896         return;
1897     }
1898
1899     CHIP_ERROR err
1900         = self.cppCluster.MoveSaturation(onSuccess->Cancel(), onFailure->Cancel(), moveMode, rate, optionsMask, optionsOverride);
1901     if (err != CHIP_NO_ERROR) {
1902         delete onSuccess;
1903         delete onFailure;
1904         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1905     }
1906 }
1907 - (void)moveToColor:(uint16_t)colorX
1908                colorY:(uint16_t)colorY
1909        transitionTime:(uint16_t)transitionTime
1910           optionsMask:(uint8_t)optionsMask
1911       optionsOverride:(uint8_t)optionsOverride
1912     completionHandler:(ResponseHandler)completionHandler
1913 {
1914     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1915     if (!onSuccess) {
1916         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1917         return;
1918     }
1919
1920     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1921     if (!onFailure) {
1922         delete onSuccess;
1923         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1924         return;
1925     }
1926
1927     CHIP_ERROR err = self.cppCluster.MoveToColor(
1928         onSuccess->Cancel(), onFailure->Cancel(), colorX, colorY, transitionTime, optionsMask, optionsOverride);
1929     if (err != CHIP_NO_ERROR) {
1930         delete onSuccess;
1931         delete onFailure;
1932         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1933     }
1934 }
1935 - (void)moveToColorTemperature:(uint16_t)colorTemperature
1936                 transitionTime:(uint16_t)transitionTime
1937                    optionsMask:(uint8_t)optionsMask
1938                optionsOverride:(uint8_t)optionsOverride
1939              completionHandler:(ResponseHandler)completionHandler
1940 {
1941     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1942     if (!onSuccess) {
1943         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1944         return;
1945     }
1946
1947     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1948     if (!onFailure) {
1949         delete onSuccess;
1950         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1951         return;
1952     }
1953
1954     CHIP_ERROR err = self.cppCluster.MoveToColorTemperature(
1955         onSuccess->Cancel(), onFailure->Cancel(), colorTemperature, transitionTime, optionsMask, optionsOverride);
1956     if (err != CHIP_NO_ERROR) {
1957         delete onSuccess;
1958         delete onFailure;
1959         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1960     }
1961 }
1962 - (void)moveToHue:(uint8_t)hue
1963             direction:(uint8_t)direction
1964        transitionTime:(uint16_t)transitionTime
1965           optionsMask:(uint8_t)optionsMask
1966       optionsOverride:(uint8_t)optionsOverride
1967     completionHandler:(ResponseHandler)completionHandler
1968 {
1969     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1970     if (!onSuccess) {
1971         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1972         return;
1973     }
1974
1975     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1976     if (!onFailure) {
1977         delete onSuccess;
1978         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1979         return;
1980     }
1981
1982     CHIP_ERROR err = self.cppCluster.MoveToHue(
1983         onSuccess->Cancel(), onFailure->Cancel(), hue, direction, transitionTime, optionsMask, optionsOverride);
1984     if (err != CHIP_NO_ERROR) {
1985         delete onSuccess;
1986         delete onFailure;
1987         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1988     }
1989 }
1990 - (void)moveToHueAndSaturation:(uint8_t)hue
1991                     saturation:(uint8_t)saturation
1992                 transitionTime:(uint16_t)transitionTime
1993                    optionsMask:(uint8_t)optionsMask
1994                optionsOverride:(uint8_t)optionsOverride
1995              completionHandler:(ResponseHandler)completionHandler
1996 {
1997     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1998     if (!onSuccess) {
1999         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2000         return;
2001     }
2002
2003     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2004     if (!onFailure) {
2005         delete onSuccess;
2006         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2007         return;
2008     }
2009
2010     CHIP_ERROR err = self.cppCluster.MoveToHueAndSaturation(
2011         onSuccess->Cancel(), onFailure->Cancel(), hue, saturation, transitionTime, optionsMask, optionsOverride);
2012     if (err != CHIP_NO_ERROR) {
2013         delete onSuccess;
2014         delete onFailure;
2015         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2016     }
2017 }
2018 - (void)moveToSaturation:(uint8_t)saturation
2019           transitionTime:(uint16_t)transitionTime
2020              optionsMask:(uint8_t)optionsMask
2021          optionsOverride:(uint8_t)optionsOverride
2022        completionHandler:(ResponseHandler)completionHandler
2023 {
2024     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2025     if (!onSuccess) {
2026         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2027         return;
2028     }
2029
2030     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2031     if (!onFailure) {
2032         delete onSuccess;
2033         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2034         return;
2035     }
2036
2037     CHIP_ERROR err = self.cppCluster.MoveToSaturation(
2038         onSuccess->Cancel(), onFailure->Cancel(), saturation, transitionTime, optionsMask, optionsOverride);
2039     if (err != CHIP_NO_ERROR) {
2040         delete onSuccess;
2041         delete onFailure;
2042         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2043     }
2044 }
2045 - (void)stepColor:(int16_t)stepX
2046                 stepY:(int16_t)stepY
2047        transitionTime:(uint16_t)transitionTime
2048           optionsMask:(uint8_t)optionsMask
2049       optionsOverride:(uint8_t)optionsOverride
2050     completionHandler:(ResponseHandler)completionHandler
2051 {
2052     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2053     if (!onSuccess) {
2054         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2055         return;
2056     }
2057
2058     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2059     if (!onFailure) {
2060         delete onSuccess;
2061         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2062         return;
2063     }
2064
2065     CHIP_ERROR err = self.cppCluster.StepColor(
2066         onSuccess->Cancel(), onFailure->Cancel(), stepX, stepY, transitionTime, optionsMask, optionsOverride);
2067     if (err != CHIP_NO_ERROR) {
2068         delete onSuccess;
2069         delete onFailure;
2070         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2071     }
2072 }
2073 - (void)stepColorTemperature:(uint8_t)stepMode
2074                     stepSize:(uint16_t)stepSize
2075               transitionTime:(uint16_t)transitionTime
2076      colorTemperatureMinimum:(uint16_t)colorTemperatureMinimum
2077      colorTemperatureMaximum:(uint16_t)colorTemperatureMaximum
2078                  optionsMask:(uint8_t)optionsMask
2079              optionsOverride:(uint8_t)optionsOverride
2080            completionHandler:(ResponseHandler)completionHandler
2081 {
2082     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2083     if (!onSuccess) {
2084         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2085         return;
2086     }
2087
2088     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2089     if (!onFailure) {
2090         delete onSuccess;
2091         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2092         return;
2093     }
2094
2095     CHIP_ERROR err = self.cppCluster.StepColorTemperature(onSuccess->Cancel(), onFailure->Cancel(), stepMode, stepSize,
2096         transitionTime, colorTemperatureMinimum, colorTemperatureMaximum, optionsMask, optionsOverride);
2097     if (err != CHIP_NO_ERROR) {
2098         delete onSuccess;
2099         delete onFailure;
2100         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2101     }
2102 }
2103 - (void)stepHue:(uint8_t)stepMode
2104              stepSize:(uint8_t)stepSize
2105        transitionTime:(uint8_t)transitionTime
2106           optionsMask:(uint8_t)optionsMask
2107       optionsOverride:(uint8_t)optionsOverride
2108     completionHandler:(ResponseHandler)completionHandler
2109 {
2110     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2111     if (!onSuccess) {
2112         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2113         return;
2114     }
2115
2116     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2117     if (!onFailure) {
2118         delete onSuccess;
2119         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2120         return;
2121     }
2122
2123     CHIP_ERROR err = self.cppCluster.StepHue(
2124         onSuccess->Cancel(), onFailure->Cancel(), stepMode, stepSize, transitionTime, optionsMask, optionsOverride);
2125     if (err != CHIP_NO_ERROR) {
2126         delete onSuccess;
2127         delete onFailure;
2128         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2129     }
2130 }
2131 - (void)stepSaturation:(uint8_t)stepMode
2132               stepSize:(uint8_t)stepSize
2133         transitionTime:(uint8_t)transitionTime
2134            optionsMask:(uint8_t)optionsMask
2135        optionsOverride:(uint8_t)optionsOverride
2136      completionHandler:(ResponseHandler)completionHandler
2137 {
2138     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2139     if (!onSuccess) {
2140         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2141         return;
2142     }
2143
2144     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2145     if (!onFailure) {
2146         delete onSuccess;
2147         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2148         return;
2149     }
2150
2151     CHIP_ERROR err = self.cppCluster.StepSaturation(
2152         onSuccess->Cancel(), onFailure->Cancel(), stepMode, stepSize, transitionTime, optionsMask, optionsOverride);
2153     if (err != CHIP_NO_ERROR) {
2154         delete onSuccess;
2155         delete onFailure;
2156         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2157     }
2158 }
2159 - (void)stopMoveStep:(uint8_t)optionsMask
2160       optionsOverride:(uint8_t)optionsOverride
2161     completionHandler:(ResponseHandler)completionHandler
2162 {
2163     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2164     if (!onSuccess) {
2165         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2166         return;
2167     }
2168
2169     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2170     if (!onFailure) {
2171         delete onSuccess;
2172         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2173         return;
2174     }
2175
2176     CHIP_ERROR err = self.cppCluster.StopMoveStep(onSuccess->Cancel(), onFailure->Cancel(), optionsMask, optionsOverride);
2177     if (err != CHIP_NO_ERROR) {
2178         delete onSuccess;
2179         delete onFailure;
2180         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2181     }
2182 }
2183
2184 - (void)readAttributeCurrentHue:(ResponseHandler)completionHandler
2185 {
2186     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2187     if (!onSuccess) {
2188         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2189         return;
2190     }
2191
2192     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2193     if (!onFailure) {
2194         delete onSuccess;
2195         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2196         return;
2197     }
2198
2199     CHIP_ERROR err = self.cppCluster.ReadAttributeCurrentHue(onSuccess->Cancel(), onFailure->Cancel());
2200     if (err != CHIP_NO_ERROR) {
2201         delete onSuccess;
2202         delete onFailure;
2203         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2204     }
2205 }
2206
2207 - (void)configureAttributeCurrentHue:(uint16_t)minInterval
2208                          maxInterval:(uint16_t)maxInterval
2209                               change:(uint8_t)change
2210                    completionHandler:(ResponseHandler)completionHandler
2211 {
2212     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2213     if (!onSuccess) {
2214         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2215         return;
2216     }
2217
2218     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2219     if (!onFailure) {
2220         delete onSuccess;
2221         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2222         return;
2223     }
2224
2225     CHIP_ERROR err
2226         = self.cppCluster.ConfigureAttributeCurrentHue(onSuccess->Cancel(), onFailure->Cancel(), minInterval, maxInterval, change);
2227     if (err != CHIP_NO_ERROR) {
2228         delete onSuccess;
2229         delete onFailure;
2230         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2231     }
2232 }
2233
2234 - (void)reportAttributeCurrentHue:(ResponseHandler)reportHandler
2235 {
2236     CHIPInt8uAttributeCallbackBridge * onReport = new CHIPInt8uAttributeCallbackBridge(reportHandler, [self callbackQueue], true);
2237     if (!onReport) {
2238         reportHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2239         return;
2240     }
2241
2242     CHIP_ERROR err = self.cppCluster.ReportAttributeCurrentHue(onReport->Cancel());
2243     if (err != CHIP_NO_ERROR) {
2244         delete onReport;
2245         reportHandler([CHIPError errorForCHIPErrorCode:err], nil);
2246     }
2247 }
2248
2249 - (void)readAttributeCurrentSaturation:(ResponseHandler)completionHandler
2250 {
2251     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2252     if (!onSuccess) {
2253         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2254         return;
2255     }
2256
2257     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2258     if (!onFailure) {
2259         delete onSuccess;
2260         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2261         return;
2262     }
2263
2264     CHIP_ERROR err = self.cppCluster.ReadAttributeCurrentSaturation(onSuccess->Cancel(), onFailure->Cancel());
2265     if (err != CHIP_NO_ERROR) {
2266         delete onSuccess;
2267         delete onFailure;
2268         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2269     }
2270 }
2271
2272 - (void)configureAttributeCurrentSaturation:(uint16_t)minInterval
2273                                 maxInterval:(uint16_t)maxInterval
2274                                      change:(uint8_t)change
2275                           completionHandler:(ResponseHandler)completionHandler
2276 {
2277     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2278     if (!onSuccess) {
2279         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2280         return;
2281     }
2282
2283     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2284     if (!onFailure) {
2285         delete onSuccess;
2286         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2287         return;
2288     }
2289
2290     CHIP_ERROR err = self.cppCluster.ConfigureAttributeCurrentSaturation(
2291         onSuccess->Cancel(), onFailure->Cancel(), minInterval, maxInterval, change);
2292     if (err != CHIP_NO_ERROR) {
2293         delete onSuccess;
2294         delete onFailure;
2295         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2296     }
2297 }
2298
2299 - (void)reportAttributeCurrentSaturation:(ResponseHandler)reportHandler
2300 {
2301     CHIPInt8uAttributeCallbackBridge * onReport = new CHIPInt8uAttributeCallbackBridge(reportHandler, [self callbackQueue], true);
2302     if (!onReport) {
2303         reportHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2304         return;
2305     }
2306
2307     CHIP_ERROR err = self.cppCluster.ReportAttributeCurrentSaturation(onReport->Cancel());
2308     if (err != CHIP_NO_ERROR) {
2309         delete onReport;
2310         reportHandler([CHIPError errorForCHIPErrorCode:err], nil);
2311     }
2312 }
2313
2314 - (void)readAttributeRemainingTime:(ResponseHandler)completionHandler
2315 {
2316     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2317     if (!onSuccess) {
2318         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2319         return;
2320     }
2321
2322     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2323     if (!onFailure) {
2324         delete onSuccess;
2325         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2326         return;
2327     }
2328
2329     CHIP_ERROR err = self.cppCluster.ReadAttributeRemainingTime(onSuccess->Cancel(), onFailure->Cancel());
2330     if (err != CHIP_NO_ERROR) {
2331         delete onSuccess;
2332         delete onFailure;
2333         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2334     }
2335 }
2336
2337 - (void)readAttributeCurrentX:(ResponseHandler)completionHandler
2338 {
2339     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2340     if (!onSuccess) {
2341         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2342         return;
2343     }
2344
2345     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2346     if (!onFailure) {
2347         delete onSuccess;
2348         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2349         return;
2350     }
2351
2352     CHIP_ERROR err = self.cppCluster.ReadAttributeCurrentX(onSuccess->Cancel(), onFailure->Cancel());
2353     if (err != CHIP_NO_ERROR) {
2354         delete onSuccess;
2355         delete onFailure;
2356         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2357     }
2358 }
2359
2360 - (void)configureAttributeCurrentX:(uint16_t)minInterval
2361                        maxInterval:(uint16_t)maxInterval
2362                             change:(uint16_t)change
2363                  completionHandler:(ResponseHandler)completionHandler
2364 {
2365     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2366     if (!onSuccess) {
2367         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2368         return;
2369     }
2370
2371     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2372     if (!onFailure) {
2373         delete onSuccess;
2374         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2375         return;
2376     }
2377
2378     CHIP_ERROR err
2379         = self.cppCluster.ConfigureAttributeCurrentX(onSuccess->Cancel(), onFailure->Cancel(), minInterval, maxInterval, change);
2380     if (err != CHIP_NO_ERROR) {
2381         delete onSuccess;
2382         delete onFailure;
2383         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2384     }
2385 }
2386
2387 - (void)reportAttributeCurrentX:(ResponseHandler)reportHandler
2388 {
2389     CHIPInt16uAttributeCallbackBridge * onReport = new CHIPInt16uAttributeCallbackBridge(reportHandler, [self callbackQueue], true);
2390     if (!onReport) {
2391         reportHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2392         return;
2393     }
2394
2395     CHIP_ERROR err = self.cppCluster.ReportAttributeCurrentX(onReport->Cancel());
2396     if (err != CHIP_NO_ERROR) {
2397         delete onReport;
2398         reportHandler([CHIPError errorForCHIPErrorCode:err], nil);
2399     }
2400 }
2401
2402 - (void)readAttributeCurrentY:(ResponseHandler)completionHandler
2403 {
2404     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2405     if (!onSuccess) {
2406         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2407         return;
2408     }
2409
2410     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2411     if (!onFailure) {
2412         delete onSuccess;
2413         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2414         return;
2415     }
2416
2417     CHIP_ERROR err = self.cppCluster.ReadAttributeCurrentY(onSuccess->Cancel(), onFailure->Cancel());
2418     if (err != CHIP_NO_ERROR) {
2419         delete onSuccess;
2420         delete onFailure;
2421         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2422     }
2423 }
2424
2425 - (void)configureAttributeCurrentY:(uint16_t)minInterval
2426                        maxInterval:(uint16_t)maxInterval
2427                             change:(uint16_t)change
2428                  completionHandler:(ResponseHandler)completionHandler
2429 {
2430     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2431     if (!onSuccess) {
2432         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2433         return;
2434     }
2435
2436     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2437     if (!onFailure) {
2438         delete onSuccess;
2439         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2440         return;
2441     }
2442
2443     CHIP_ERROR err
2444         = self.cppCluster.ConfigureAttributeCurrentY(onSuccess->Cancel(), onFailure->Cancel(), minInterval, maxInterval, change);
2445     if (err != CHIP_NO_ERROR) {
2446         delete onSuccess;
2447         delete onFailure;
2448         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2449     }
2450 }
2451
2452 - (void)reportAttributeCurrentY:(ResponseHandler)reportHandler
2453 {
2454     CHIPInt16uAttributeCallbackBridge * onReport = new CHIPInt16uAttributeCallbackBridge(reportHandler, [self callbackQueue], true);
2455     if (!onReport) {
2456         reportHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2457         return;
2458     }
2459
2460     CHIP_ERROR err = self.cppCluster.ReportAttributeCurrentY(onReport->Cancel());
2461     if (err != CHIP_NO_ERROR) {
2462         delete onReport;
2463         reportHandler([CHIPError errorForCHIPErrorCode:err], nil);
2464     }
2465 }
2466
2467 - (void)readAttributeDriftCompensation:(ResponseHandler)completionHandler
2468 {
2469     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2470     if (!onSuccess) {
2471         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2472         return;
2473     }
2474
2475     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2476     if (!onFailure) {
2477         delete onSuccess;
2478         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2479         return;
2480     }
2481
2482     CHIP_ERROR err = self.cppCluster.ReadAttributeDriftCompensation(onSuccess->Cancel(), onFailure->Cancel());
2483     if (err != CHIP_NO_ERROR) {
2484         delete onSuccess;
2485         delete onFailure;
2486         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2487     }
2488 }
2489
2490 - (void)readAttributeCompensationText:(ResponseHandler)completionHandler
2491 {
2492     CHIPUnsupportedAttributeCallbackBridge * onSuccess
2493         = new CHIPUnsupportedAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2494     if (!onSuccess) {
2495         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2496         return;
2497     }
2498
2499     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2500     if (!onFailure) {
2501         delete onSuccess;
2502         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2503         return;
2504     }
2505
2506     CHIP_ERROR err = self.cppCluster.ReadAttributeCompensationText(onSuccess->Cancel(), onFailure->Cancel());
2507     if (err != CHIP_NO_ERROR) {
2508         delete onSuccess;
2509         delete onFailure;
2510         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2511     }
2512 }
2513
2514 - (void)readAttributeColorTemperature:(ResponseHandler)completionHandler
2515 {
2516     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2517     if (!onSuccess) {
2518         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2519         return;
2520     }
2521
2522     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2523     if (!onFailure) {
2524         delete onSuccess;
2525         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2526         return;
2527     }
2528
2529     CHIP_ERROR err = self.cppCluster.ReadAttributeColorTemperature(onSuccess->Cancel(), onFailure->Cancel());
2530     if (err != CHIP_NO_ERROR) {
2531         delete onSuccess;
2532         delete onFailure;
2533         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2534     }
2535 }
2536
2537 - (void)configureAttributeColorTemperature:(uint16_t)minInterval
2538                                maxInterval:(uint16_t)maxInterval
2539                                     change:(uint16_t)change
2540                          completionHandler:(ResponseHandler)completionHandler
2541 {
2542     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2543     if (!onSuccess) {
2544         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2545         return;
2546     }
2547
2548     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2549     if (!onFailure) {
2550         delete onSuccess;
2551         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2552         return;
2553     }
2554
2555     CHIP_ERROR err = self.cppCluster.ConfigureAttributeColorTemperature(
2556         onSuccess->Cancel(), onFailure->Cancel(), minInterval, maxInterval, change);
2557     if (err != CHIP_NO_ERROR) {
2558         delete onSuccess;
2559         delete onFailure;
2560         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2561     }
2562 }
2563
2564 - (void)reportAttributeColorTemperature:(ResponseHandler)reportHandler
2565 {
2566     CHIPInt16uAttributeCallbackBridge * onReport = new CHIPInt16uAttributeCallbackBridge(reportHandler, [self callbackQueue], true);
2567     if (!onReport) {
2568         reportHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2569         return;
2570     }
2571
2572     CHIP_ERROR err = self.cppCluster.ReportAttributeColorTemperature(onReport->Cancel());
2573     if (err != CHIP_NO_ERROR) {
2574         delete onReport;
2575         reportHandler([CHIPError errorForCHIPErrorCode:err], nil);
2576     }
2577 }
2578
2579 - (void)readAttributeColorMode:(ResponseHandler)completionHandler
2580 {
2581     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2582     if (!onSuccess) {
2583         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2584         return;
2585     }
2586
2587     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2588     if (!onFailure) {
2589         delete onSuccess;
2590         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2591         return;
2592     }
2593
2594     CHIP_ERROR err = self.cppCluster.ReadAttributeColorMode(onSuccess->Cancel(), onFailure->Cancel());
2595     if (err != CHIP_NO_ERROR) {
2596         delete onSuccess;
2597         delete onFailure;
2598         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2599     }
2600 }
2601
2602 - (void)readAttributeColorControlOptions:(ResponseHandler)completionHandler
2603 {
2604     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2605     if (!onSuccess) {
2606         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2607         return;
2608     }
2609
2610     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2611     if (!onFailure) {
2612         delete onSuccess;
2613         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2614         return;
2615     }
2616
2617     CHIP_ERROR err = self.cppCluster.ReadAttributeColorControlOptions(onSuccess->Cancel(), onFailure->Cancel());
2618     if (err != CHIP_NO_ERROR) {
2619         delete onSuccess;
2620         delete onFailure;
2621         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2622     }
2623 }
2624
2625 - (void)writeAttributeColorControlOptions:(uint8_t)value completionHandler:(ResponseHandler)completionHandler
2626 {
2627     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
2628     if (!onSuccess) {
2629         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2630         return;
2631     }
2632
2633     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2634     if (!onFailure) {
2635         delete onSuccess;
2636         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2637         return;
2638     }
2639
2640     CHIP_ERROR err = self.cppCluster.WriteAttributeColorControlOptions(onSuccess->Cancel(), onFailure->Cancel(), value);
2641     if (err != CHIP_NO_ERROR) {
2642         delete onSuccess;
2643         delete onFailure;
2644         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2645     }
2646 }
2647
2648 - (void)readAttributeNumberOfPrimaries:(ResponseHandler)completionHandler
2649 {
2650     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2651     if (!onSuccess) {
2652         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2653         return;
2654     }
2655
2656     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2657     if (!onFailure) {
2658         delete onSuccess;
2659         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2660         return;
2661     }
2662
2663     CHIP_ERROR err = self.cppCluster.ReadAttributeNumberOfPrimaries(onSuccess->Cancel(), onFailure->Cancel());
2664     if (err != CHIP_NO_ERROR) {
2665         delete onSuccess;
2666         delete onFailure;
2667         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2668     }
2669 }
2670
2671 - (void)readAttributePrimary1X:(ResponseHandler)completionHandler
2672 {
2673     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2674     if (!onSuccess) {
2675         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2676         return;
2677     }
2678
2679     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2680     if (!onFailure) {
2681         delete onSuccess;
2682         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2683         return;
2684     }
2685
2686     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary1X(onSuccess->Cancel(), onFailure->Cancel());
2687     if (err != CHIP_NO_ERROR) {
2688         delete onSuccess;
2689         delete onFailure;
2690         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2691     }
2692 }
2693
2694 - (void)readAttributePrimary1Y:(ResponseHandler)completionHandler
2695 {
2696     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2697     if (!onSuccess) {
2698         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2699         return;
2700     }
2701
2702     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2703     if (!onFailure) {
2704         delete onSuccess;
2705         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2706         return;
2707     }
2708
2709     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary1Y(onSuccess->Cancel(), onFailure->Cancel());
2710     if (err != CHIP_NO_ERROR) {
2711         delete onSuccess;
2712         delete onFailure;
2713         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2714     }
2715 }
2716
2717 - (void)readAttributePrimary1Intensity:(ResponseHandler)completionHandler
2718 {
2719     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2720     if (!onSuccess) {
2721         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2722         return;
2723     }
2724
2725     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2726     if (!onFailure) {
2727         delete onSuccess;
2728         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2729         return;
2730     }
2731
2732     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary1Intensity(onSuccess->Cancel(), onFailure->Cancel());
2733     if (err != CHIP_NO_ERROR) {
2734         delete onSuccess;
2735         delete onFailure;
2736         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2737     }
2738 }
2739
2740 - (void)readAttributePrimary2X:(ResponseHandler)completionHandler
2741 {
2742     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2743     if (!onSuccess) {
2744         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2745         return;
2746     }
2747
2748     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2749     if (!onFailure) {
2750         delete onSuccess;
2751         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2752         return;
2753     }
2754
2755     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary2X(onSuccess->Cancel(), onFailure->Cancel());
2756     if (err != CHIP_NO_ERROR) {
2757         delete onSuccess;
2758         delete onFailure;
2759         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2760     }
2761 }
2762
2763 - (void)readAttributePrimary2Y:(ResponseHandler)completionHandler
2764 {
2765     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2766     if (!onSuccess) {
2767         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2768         return;
2769     }
2770
2771     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2772     if (!onFailure) {
2773         delete onSuccess;
2774         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2775         return;
2776     }
2777
2778     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary2Y(onSuccess->Cancel(), onFailure->Cancel());
2779     if (err != CHIP_NO_ERROR) {
2780         delete onSuccess;
2781         delete onFailure;
2782         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2783     }
2784 }
2785
2786 - (void)readAttributePrimary2Intensity:(ResponseHandler)completionHandler
2787 {
2788     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2789     if (!onSuccess) {
2790         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2791         return;
2792     }
2793
2794     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2795     if (!onFailure) {
2796         delete onSuccess;
2797         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2798         return;
2799     }
2800
2801     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary2Intensity(onSuccess->Cancel(), onFailure->Cancel());
2802     if (err != CHIP_NO_ERROR) {
2803         delete onSuccess;
2804         delete onFailure;
2805         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2806     }
2807 }
2808
2809 - (void)readAttributePrimary3X:(ResponseHandler)completionHandler
2810 {
2811     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2812     if (!onSuccess) {
2813         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2814         return;
2815     }
2816
2817     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2818     if (!onFailure) {
2819         delete onSuccess;
2820         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2821         return;
2822     }
2823
2824     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary3X(onSuccess->Cancel(), onFailure->Cancel());
2825     if (err != CHIP_NO_ERROR) {
2826         delete onSuccess;
2827         delete onFailure;
2828         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2829     }
2830 }
2831
2832 - (void)readAttributePrimary3Y:(ResponseHandler)completionHandler
2833 {
2834     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2835     if (!onSuccess) {
2836         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2837         return;
2838     }
2839
2840     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2841     if (!onFailure) {
2842         delete onSuccess;
2843         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2844         return;
2845     }
2846
2847     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary3Y(onSuccess->Cancel(), onFailure->Cancel());
2848     if (err != CHIP_NO_ERROR) {
2849         delete onSuccess;
2850         delete onFailure;
2851         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2852     }
2853 }
2854
2855 - (void)readAttributePrimary3Intensity:(ResponseHandler)completionHandler
2856 {
2857     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2858     if (!onSuccess) {
2859         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2860         return;
2861     }
2862
2863     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2864     if (!onFailure) {
2865         delete onSuccess;
2866         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2867         return;
2868     }
2869
2870     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary3Intensity(onSuccess->Cancel(), onFailure->Cancel());
2871     if (err != CHIP_NO_ERROR) {
2872         delete onSuccess;
2873         delete onFailure;
2874         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2875     }
2876 }
2877
2878 - (void)readAttributePrimary4X:(ResponseHandler)completionHandler
2879 {
2880     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2881     if (!onSuccess) {
2882         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2883         return;
2884     }
2885
2886     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2887     if (!onFailure) {
2888         delete onSuccess;
2889         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2890         return;
2891     }
2892
2893     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary4X(onSuccess->Cancel(), onFailure->Cancel());
2894     if (err != CHIP_NO_ERROR) {
2895         delete onSuccess;
2896         delete onFailure;
2897         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2898     }
2899 }
2900
2901 - (void)readAttributePrimary4Y:(ResponseHandler)completionHandler
2902 {
2903     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2904     if (!onSuccess) {
2905         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2906         return;
2907     }
2908
2909     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2910     if (!onFailure) {
2911         delete onSuccess;
2912         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2913         return;
2914     }
2915
2916     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary4Y(onSuccess->Cancel(), onFailure->Cancel());
2917     if (err != CHIP_NO_ERROR) {
2918         delete onSuccess;
2919         delete onFailure;
2920         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2921     }
2922 }
2923
2924 - (void)readAttributePrimary4Intensity:(ResponseHandler)completionHandler
2925 {
2926     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2927     if (!onSuccess) {
2928         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2929         return;
2930     }
2931
2932     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2933     if (!onFailure) {
2934         delete onSuccess;
2935         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2936         return;
2937     }
2938
2939     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary4Intensity(onSuccess->Cancel(), onFailure->Cancel());
2940     if (err != CHIP_NO_ERROR) {
2941         delete onSuccess;
2942         delete onFailure;
2943         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2944     }
2945 }
2946
2947 - (void)readAttributePrimary5X:(ResponseHandler)completionHandler
2948 {
2949     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2950     if (!onSuccess) {
2951         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2952         return;
2953     }
2954
2955     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2956     if (!onFailure) {
2957         delete onSuccess;
2958         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2959         return;
2960     }
2961
2962     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary5X(onSuccess->Cancel(), onFailure->Cancel());
2963     if (err != CHIP_NO_ERROR) {
2964         delete onSuccess;
2965         delete onFailure;
2966         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2967     }
2968 }
2969
2970 - (void)readAttributePrimary5Y:(ResponseHandler)completionHandler
2971 {
2972     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2973     if (!onSuccess) {
2974         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2975         return;
2976     }
2977
2978     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
2979     if (!onFailure) {
2980         delete onSuccess;
2981         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2982         return;
2983     }
2984
2985     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary5Y(onSuccess->Cancel(), onFailure->Cancel());
2986     if (err != CHIP_NO_ERROR) {
2987         delete onSuccess;
2988         delete onFailure;
2989         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
2990     }
2991 }
2992
2993 - (void)readAttributePrimary5Intensity:(ResponseHandler)completionHandler
2994 {
2995     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
2996     if (!onSuccess) {
2997         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
2998         return;
2999     }
3000
3001     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3002     if (!onFailure) {
3003         delete onSuccess;
3004         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3005         return;
3006     }
3007
3008     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary5Intensity(onSuccess->Cancel(), onFailure->Cancel());
3009     if (err != CHIP_NO_ERROR) {
3010         delete onSuccess;
3011         delete onFailure;
3012         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3013     }
3014 }
3015
3016 - (void)readAttributePrimary6X:(ResponseHandler)completionHandler
3017 {
3018     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
3019     if (!onSuccess) {
3020         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3021         return;
3022     }
3023
3024     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3025     if (!onFailure) {
3026         delete onSuccess;
3027         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3028         return;
3029     }
3030
3031     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary6X(onSuccess->Cancel(), onFailure->Cancel());
3032     if (err != CHIP_NO_ERROR) {
3033         delete onSuccess;
3034         delete onFailure;
3035         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3036     }
3037 }
3038
3039 - (void)readAttributePrimary6Y:(ResponseHandler)completionHandler
3040 {
3041     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
3042     if (!onSuccess) {
3043         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3044         return;
3045     }
3046
3047     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3048     if (!onFailure) {
3049         delete onSuccess;
3050         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3051         return;
3052     }
3053
3054     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary6Y(onSuccess->Cancel(), onFailure->Cancel());
3055     if (err != CHIP_NO_ERROR) {
3056         delete onSuccess;
3057         delete onFailure;
3058         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3059     }
3060 }
3061
3062 - (void)readAttributePrimary6Intensity:(ResponseHandler)completionHandler
3063 {
3064     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
3065     if (!onSuccess) {
3066         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3067         return;
3068     }
3069
3070     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3071     if (!onFailure) {
3072         delete onSuccess;
3073         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3074         return;
3075     }
3076
3077     CHIP_ERROR err = self.cppCluster.ReadAttributePrimary6Intensity(onSuccess->Cancel(), onFailure->Cancel());
3078     if (err != CHIP_NO_ERROR) {
3079         delete onSuccess;
3080         delete onFailure;
3081         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3082     }
3083 }
3084
3085 - (void)readAttributeWhitePointX:(ResponseHandler)completionHandler
3086 {
3087     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
3088     if (!onSuccess) {
3089         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3090         return;
3091     }
3092
3093     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3094     if (!onFailure) {
3095         delete onSuccess;
3096         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3097         return;
3098     }
3099
3100     CHIP_ERROR err = self.cppCluster.ReadAttributeWhitePointX(onSuccess->Cancel(), onFailure->Cancel());
3101     if (err != CHIP_NO_ERROR) {
3102         delete onSuccess;
3103         delete onFailure;
3104         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3105     }
3106 }
3107
3108 - (void)writeAttributeWhitePointX:(uint16_t)value completionHandler:(ResponseHandler)completionHandler
3109 {
3110     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
3111     if (!onSuccess) {
3112         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3113         return;
3114     }
3115
3116     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3117     if (!onFailure) {
3118         delete onSuccess;
3119         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3120         return;
3121     }
3122
3123     CHIP_ERROR err = self.cppCluster.WriteAttributeWhitePointX(onSuccess->Cancel(), onFailure->Cancel(), value);
3124     if (err != CHIP_NO_ERROR) {
3125         delete onSuccess;
3126         delete onFailure;
3127         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3128     }
3129 }
3130
3131 - (void)readAttributeWhitePointY:(ResponseHandler)completionHandler
3132 {
3133     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
3134     if (!onSuccess) {
3135         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3136         return;
3137     }
3138
3139     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3140     if (!onFailure) {
3141         delete onSuccess;
3142         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3143         return;
3144     }
3145
3146     CHIP_ERROR err = self.cppCluster.ReadAttributeWhitePointY(onSuccess->Cancel(), onFailure->Cancel());
3147     if (err != CHIP_NO_ERROR) {
3148         delete onSuccess;
3149         delete onFailure;
3150         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3151     }
3152 }
3153
3154 - (void)writeAttributeWhitePointY:(uint16_t)value completionHandler:(ResponseHandler)completionHandler
3155 {
3156     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
3157     if (!onSuccess) {
3158         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3159         return;
3160     }
3161
3162     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3163     if (!onFailure) {
3164         delete onSuccess;
3165         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3166         return;
3167     }
3168
3169     CHIP_ERROR err = self.cppCluster.WriteAttributeWhitePointY(onSuccess->Cancel(), onFailure->Cancel(), value);
3170     if (err != CHIP_NO_ERROR) {
3171         delete onSuccess;
3172         delete onFailure;
3173         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3174     }
3175 }
3176
3177 - (void)readAttributeColorPointRX:(ResponseHandler)completionHandler
3178 {
3179     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
3180     if (!onSuccess) {
3181         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3182         return;
3183     }
3184
3185     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3186     if (!onFailure) {
3187         delete onSuccess;
3188         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3189         return;
3190     }
3191
3192     CHIP_ERROR err = self.cppCluster.ReadAttributeColorPointRX(onSuccess->Cancel(), onFailure->Cancel());
3193     if (err != CHIP_NO_ERROR) {
3194         delete onSuccess;
3195         delete onFailure;
3196         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3197     }
3198 }
3199
3200 - (void)writeAttributeColorPointRX:(uint16_t)value completionHandler:(ResponseHandler)completionHandler
3201 {
3202     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
3203     if (!onSuccess) {
3204         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3205         return;
3206     }
3207
3208     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3209     if (!onFailure) {
3210         delete onSuccess;
3211         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3212         return;
3213     }
3214
3215     CHIP_ERROR err = self.cppCluster.WriteAttributeColorPointRX(onSuccess->Cancel(), onFailure->Cancel(), value);
3216     if (err != CHIP_NO_ERROR) {
3217         delete onSuccess;
3218         delete onFailure;
3219         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3220     }
3221 }
3222
3223 - (void)readAttributeColorPointRY:(ResponseHandler)completionHandler
3224 {
3225     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
3226     if (!onSuccess) {
3227         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3228         return;
3229     }
3230
3231     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3232     if (!onFailure) {
3233         delete onSuccess;
3234         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3235         return;
3236     }
3237
3238     CHIP_ERROR err = self.cppCluster.ReadAttributeColorPointRY(onSuccess->Cancel(), onFailure->Cancel());
3239     if (err != CHIP_NO_ERROR) {
3240         delete onSuccess;
3241         delete onFailure;
3242         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3243     }
3244 }
3245
3246 - (void)writeAttributeColorPointRY:(uint16_t)value completionHandler:(ResponseHandler)completionHandler
3247 {
3248     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
3249     if (!onSuccess) {
3250         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3251         return;
3252     }
3253
3254     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3255     if (!onFailure) {
3256         delete onSuccess;
3257         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3258         return;
3259     }
3260
3261     CHIP_ERROR err = self.cppCluster.WriteAttributeColorPointRY(onSuccess->Cancel(), onFailure->Cancel(), value);
3262     if (err != CHIP_NO_ERROR) {
3263         delete onSuccess;
3264         delete onFailure;
3265         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3266     }
3267 }
3268
3269 - (void)readAttributeColorPointRIntensity:(ResponseHandler)completionHandler
3270 {
3271     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
3272     if (!onSuccess) {
3273         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3274         return;
3275     }
3276
3277     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3278     if (!onFailure) {
3279         delete onSuccess;
3280         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3281         return;
3282     }
3283
3284     CHIP_ERROR err = self.cppCluster.ReadAttributeColorPointRIntensity(onSuccess->Cancel(), onFailure->Cancel());
3285     if (err != CHIP_NO_ERROR) {
3286         delete onSuccess;
3287         delete onFailure;
3288         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3289     }
3290 }
3291
3292 - (void)writeAttributeColorPointRIntensity:(uint8_t)value completionHandler:(ResponseHandler)completionHandler
3293 {
3294     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
3295     if (!onSuccess) {
3296         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3297         return;
3298     }
3299
3300     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3301     if (!onFailure) {
3302         delete onSuccess;
3303         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3304         return;
3305     }
3306
3307     CHIP_ERROR err = self.cppCluster.WriteAttributeColorPointRIntensity(onSuccess->Cancel(), onFailure->Cancel(), value);
3308     if (err != CHIP_NO_ERROR) {
3309         delete onSuccess;
3310         delete onFailure;
3311         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3312     }
3313 }
3314
3315 - (void)readAttributeColorPointGX:(ResponseHandler)completionHandler
3316 {
3317     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
3318     if (!onSuccess) {
3319         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3320         return;
3321     }
3322
3323     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3324     if (!onFailure) {
3325         delete onSuccess;
3326         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3327         return;
3328     }
3329
3330     CHIP_ERROR err = self.cppCluster.ReadAttributeColorPointGX(onSuccess->Cancel(), onFailure->Cancel());
3331     if (err != CHIP_NO_ERROR) {
3332         delete onSuccess;
3333         delete onFailure;
3334         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3335     }
3336 }
3337
3338 - (void)writeAttributeColorPointGX:(uint16_t)value completionHandler:(ResponseHandler)completionHandler
3339 {
3340     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
3341     if (!onSuccess) {
3342         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3343         return;
3344     }
3345
3346     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3347     if (!onFailure) {
3348         delete onSuccess;
3349         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3350         return;
3351     }
3352
3353     CHIP_ERROR err = self.cppCluster.WriteAttributeColorPointGX(onSuccess->Cancel(), onFailure->Cancel(), value);
3354     if (err != CHIP_NO_ERROR) {
3355         delete onSuccess;
3356         delete onFailure;
3357         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3358     }
3359 }
3360
3361 - (void)readAttributeColorPointGY:(ResponseHandler)completionHandler
3362 {
3363     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
3364     if (!onSuccess) {
3365         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3366         return;
3367     }
3368
3369     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3370     if (!onFailure) {
3371         delete onSuccess;
3372         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3373         return;
3374     }
3375
3376     CHIP_ERROR err = self.cppCluster.ReadAttributeColorPointGY(onSuccess->Cancel(), onFailure->Cancel());
3377     if (err != CHIP_NO_ERROR) {
3378         delete onSuccess;
3379         delete onFailure;
3380         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3381     }
3382 }
3383
3384 - (void)writeAttributeColorPointGY:(uint16_t)value completionHandler:(ResponseHandler)completionHandler
3385 {
3386     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
3387     if (!onSuccess) {
3388         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3389         return;
3390     }
3391
3392     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3393     if (!onFailure) {
3394         delete onSuccess;
3395         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3396         return;
3397     }
3398
3399     CHIP_ERROR err = self.cppCluster.WriteAttributeColorPointGY(onSuccess->Cancel(), onFailure->Cancel(), value);
3400     if (err != CHIP_NO_ERROR) {
3401         delete onSuccess;
3402         delete onFailure;
3403         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3404     }
3405 }
3406
3407 - (void)readAttributeColorPointGIntensity:(ResponseHandler)completionHandler
3408 {
3409     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
3410     if (!onSuccess) {
3411         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3412         return;
3413     }
3414
3415     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3416     if (!onFailure) {
3417         delete onSuccess;
3418         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3419         return;
3420     }
3421
3422     CHIP_ERROR err = self.cppCluster.ReadAttributeColorPointGIntensity(onSuccess->Cancel(), onFailure->Cancel());
3423     if (err != CHIP_NO_ERROR) {
3424         delete onSuccess;
3425         delete onFailure;
3426         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3427     }
3428 }
3429
3430 - (void)writeAttributeColorPointGIntensity:(uint8_t)value completionHandler:(ResponseHandler)completionHandler
3431 {
3432     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
3433     if (!onSuccess) {
3434         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3435         return;
3436     }
3437
3438     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3439     if (!onFailure) {
3440         delete onSuccess;
3441         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3442         return;
3443     }
3444
3445     CHIP_ERROR err = self.cppCluster.WriteAttributeColorPointGIntensity(onSuccess->Cancel(), onFailure->Cancel(), value);
3446     if (err != CHIP_NO_ERROR) {
3447         delete onSuccess;
3448         delete onFailure;
3449         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3450     }
3451 }
3452
3453 - (void)readAttributeColorPointBX:(ResponseHandler)completionHandler
3454 {
3455     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
3456     if (!onSuccess) {
3457         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3458         return;
3459     }
3460
3461     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3462     if (!onFailure) {
3463         delete onSuccess;
3464         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3465         return;
3466     }
3467
3468     CHIP_ERROR err = self.cppCluster.ReadAttributeColorPointBX(onSuccess->Cancel(), onFailure->Cancel());
3469     if (err != CHIP_NO_ERROR) {
3470         delete onSuccess;
3471         delete onFailure;
3472         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3473     }
3474 }
3475
3476 - (void)writeAttributeColorPointBX:(uint16_t)value completionHandler:(ResponseHandler)completionHandler
3477 {
3478     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
3479     if (!onSuccess) {
3480         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3481         return;
3482     }
3483
3484     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3485     if (!onFailure) {
3486         delete onSuccess;
3487         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3488         return;
3489     }
3490
3491     CHIP_ERROR err = self.cppCluster.WriteAttributeColorPointBX(onSuccess->Cancel(), onFailure->Cancel(), value);
3492     if (err != CHIP_NO_ERROR) {
3493         delete onSuccess;
3494         delete onFailure;
3495         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3496     }
3497 }
3498
3499 - (void)readAttributeColorPointBY:(ResponseHandler)completionHandler
3500 {
3501     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
3502     if (!onSuccess) {
3503         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3504         return;
3505     }
3506
3507     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3508     if (!onFailure) {
3509         delete onSuccess;
3510         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3511         return;
3512     }
3513
3514     CHIP_ERROR err = self.cppCluster.ReadAttributeColorPointBY(onSuccess->Cancel(), onFailure->Cancel());
3515     if (err != CHIP_NO_ERROR) {
3516         delete onSuccess;
3517         delete onFailure;
3518         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3519     }
3520 }
3521
3522 - (void)writeAttributeColorPointBY:(uint16_t)value completionHandler:(ResponseHandler)completionHandler
3523 {
3524     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
3525     if (!onSuccess) {
3526         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3527         return;
3528     }
3529
3530     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3531     if (!onFailure) {
3532         delete onSuccess;
3533         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3534         return;
3535     }
3536
3537     CHIP_ERROR err = self.cppCluster.WriteAttributeColorPointBY(onSuccess->Cancel(), onFailure->Cancel(), value);
3538     if (err != CHIP_NO_ERROR) {
3539         delete onSuccess;
3540         delete onFailure;
3541         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3542     }
3543 }
3544
3545 - (void)readAttributeColorPointBIntensity:(ResponseHandler)completionHandler
3546 {
3547     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
3548     if (!onSuccess) {
3549         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3550         return;
3551     }
3552
3553     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3554     if (!onFailure) {
3555         delete onSuccess;
3556         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3557         return;
3558     }
3559
3560     CHIP_ERROR err = self.cppCluster.ReadAttributeColorPointBIntensity(onSuccess->Cancel(), onFailure->Cancel());
3561     if (err != CHIP_NO_ERROR) {
3562         delete onSuccess;
3563         delete onFailure;
3564         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3565     }
3566 }
3567
3568 - (void)writeAttributeColorPointBIntensity:(uint8_t)value completionHandler:(ResponseHandler)completionHandler
3569 {
3570     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
3571     if (!onSuccess) {
3572         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3573         return;
3574     }
3575
3576     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3577     if (!onFailure) {
3578         delete onSuccess;
3579         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3580         return;
3581     }
3582
3583     CHIP_ERROR err = self.cppCluster.WriteAttributeColorPointBIntensity(onSuccess->Cancel(), onFailure->Cancel(), value);
3584     if (err != CHIP_NO_ERROR) {
3585         delete onSuccess;
3586         delete onFailure;
3587         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3588     }
3589 }
3590
3591 - (void)readAttributeEnhancedCurrentHue:(ResponseHandler)completionHandler
3592 {
3593     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
3594     if (!onSuccess) {
3595         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3596         return;
3597     }
3598
3599     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3600     if (!onFailure) {
3601         delete onSuccess;
3602         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3603         return;
3604     }
3605
3606     CHIP_ERROR err = self.cppCluster.ReadAttributeEnhancedCurrentHue(onSuccess->Cancel(), onFailure->Cancel());
3607     if (err != CHIP_NO_ERROR) {
3608         delete onSuccess;
3609         delete onFailure;
3610         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3611     }
3612 }
3613
3614 - (void)readAttributeEnhancedColorMode:(ResponseHandler)completionHandler
3615 {
3616     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
3617     if (!onSuccess) {
3618         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3619         return;
3620     }
3621
3622     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3623     if (!onFailure) {
3624         delete onSuccess;
3625         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3626         return;
3627     }
3628
3629     CHIP_ERROR err = self.cppCluster.ReadAttributeEnhancedColorMode(onSuccess->Cancel(), onFailure->Cancel());
3630     if (err != CHIP_NO_ERROR) {
3631         delete onSuccess;
3632         delete onFailure;
3633         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3634     }
3635 }
3636
3637 - (void)readAttributeColorLoopActive:(ResponseHandler)completionHandler
3638 {
3639     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
3640     if (!onSuccess) {
3641         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3642         return;
3643     }
3644
3645     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3646     if (!onFailure) {
3647         delete onSuccess;
3648         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3649         return;
3650     }
3651
3652     CHIP_ERROR err = self.cppCluster.ReadAttributeColorLoopActive(onSuccess->Cancel(), onFailure->Cancel());
3653     if (err != CHIP_NO_ERROR) {
3654         delete onSuccess;
3655         delete onFailure;
3656         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3657     }
3658 }
3659
3660 - (void)readAttributeColorLoopDirection:(ResponseHandler)completionHandler
3661 {
3662     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
3663     if (!onSuccess) {
3664         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3665         return;
3666     }
3667
3668     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3669     if (!onFailure) {
3670         delete onSuccess;
3671         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3672         return;
3673     }
3674
3675     CHIP_ERROR err = self.cppCluster.ReadAttributeColorLoopDirection(onSuccess->Cancel(), onFailure->Cancel());
3676     if (err != CHIP_NO_ERROR) {
3677         delete onSuccess;
3678         delete onFailure;
3679         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3680     }
3681 }
3682
3683 - (void)readAttributeColorLoopTime:(ResponseHandler)completionHandler
3684 {
3685     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
3686     if (!onSuccess) {
3687         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3688         return;
3689     }
3690
3691     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3692     if (!onFailure) {
3693         delete onSuccess;
3694         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3695         return;
3696     }
3697
3698     CHIP_ERROR err = self.cppCluster.ReadAttributeColorLoopTime(onSuccess->Cancel(), onFailure->Cancel());
3699     if (err != CHIP_NO_ERROR) {
3700         delete onSuccess;
3701         delete onFailure;
3702         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3703     }
3704 }
3705
3706 - (void)readAttributeColorCapabilities:(ResponseHandler)completionHandler
3707 {
3708     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
3709     if (!onSuccess) {
3710         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3711         return;
3712     }
3713
3714     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3715     if (!onFailure) {
3716         delete onSuccess;
3717         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3718         return;
3719     }
3720
3721     CHIP_ERROR err = self.cppCluster.ReadAttributeColorCapabilities(onSuccess->Cancel(), onFailure->Cancel());
3722     if (err != CHIP_NO_ERROR) {
3723         delete onSuccess;
3724         delete onFailure;
3725         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3726     }
3727 }
3728
3729 - (void)readAttributeColorTempPhysicalMin:(ResponseHandler)completionHandler
3730 {
3731     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
3732     if (!onSuccess) {
3733         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3734         return;
3735     }
3736
3737     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3738     if (!onFailure) {
3739         delete onSuccess;
3740         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3741         return;
3742     }
3743
3744     CHIP_ERROR err = self.cppCluster.ReadAttributeColorTempPhysicalMin(onSuccess->Cancel(), onFailure->Cancel());
3745     if (err != CHIP_NO_ERROR) {
3746         delete onSuccess;
3747         delete onFailure;
3748         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3749     }
3750 }
3751
3752 - (void)readAttributeColorTempPhysicalMax:(ResponseHandler)completionHandler
3753 {
3754     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
3755     if (!onSuccess) {
3756         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3757         return;
3758     }
3759
3760     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3761     if (!onFailure) {
3762         delete onSuccess;
3763         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3764         return;
3765     }
3766
3767     CHIP_ERROR err = self.cppCluster.ReadAttributeColorTempPhysicalMax(onSuccess->Cancel(), onFailure->Cancel());
3768     if (err != CHIP_NO_ERROR) {
3769         delete onSuccess;
3770         delete onFailure;
3771         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3772     }
3773 }
3774
3775 - (void)readAttributeCoupleColorTempToLevelMinMireds:(ResponseHandler)completionHandler
3776 {
3777     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
3778     if (!onSuccess) {
3779         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3780         return;
3781     }
3782
3783     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3784     if (!onFailure) {
3785         delete onSuccess;
3786         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3787         return;
3788     }
3789
3790     CHIP_ERROR err = self.cppCluster.ReadAttributeCoupleColorTempToLevelMinMireds(onSuccess->Cancel(), onFailure->Cancel());
3791     if (err != CHIP_NO_ERROR) {
3792         delete onSuccess;
3793         delete onFailure;
3794         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3795     }
3796 }
3797
3798 - (void)readAttributeStartUpColorTemperatureMireds:(ResponseHandler)completionHandler
3799 {
3800     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
3801     if (!onSuccess) {
3802         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3803         return;
3804     }
3805
3806     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3807     if (!onFailure) {
3808         delete onSuccess;
3809         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3810         return;
3811     }
3812
3813     CHIP_ERROR err = self.cppCluster.ReadAttributeStartUpColorTemperatureMireds(onSuccess->Cancel(), onFailure->Cancel());
3814     if (err != CHIP_NO_ERROR) {
3815         delete onSuccess;
3816         delete onFailure;
3817         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3818     }
3819 }
3820
3821 - (void)writeAttributeStartUpColorTemperatureMireds:(uint16_t)value completionHandler:(ResponseHandler)completionHandler
3822 {
3823     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
3824     if (!onSuccess) {
3825         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3826         return;
3827     }
3828
3829     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3830     if (!onFailure) {
3831         delete onSuccess;
3832         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3833         return;
3834     }
3835
3836     CHIP_ERROR err = self.cppCluster.WriteAttributeStartUpColorTemperatureMireds(onSuccess->Cancel(), onFailure->Cancel(), value);
3837     if (err != CHIP_NO_ERROR) {
3838         delete onSuccess;
3839         delete onFailure;
3840         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3841     }
3842 }
3843
3844 - (void)readAttributeClusterRevision:(ResponseHandler)completionHandler
3845 {
3846     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
3847     if (!onSuccess) {
3848         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3849         return;
3850     }
3851
3852     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3853     if (!onFailure) {
3854         delete onSuccess;
3855         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3856         return;
3857     }
3858
3859     CHIP_ERROR err = self.cppCluster.ReadAttributeClusterRevision(onSuccess->Cancel(), onFailure->Cancel());
3860     if (err != CHIP_NO_ERROR) {
3861         delete onSuccess;
3862         delete onFailure;
3863         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3864     }
3865 }
3866
3867 @end
3868
3869 @interface CHIPDoorLock ()
3870 @property (readonly) Controller::DoorLockCluster cppCluster;
3871 @end
3872
3873 @implementation CHIPDoorLock
3874
3875 - (Controller::ClusterBase *)getCluster
3876 {
3877     return &_cppCluster;
3878 }
3879
3880 - (void)clearAllPins:(ResponseHandler)completionHandler
3881 {
3882     CHIPDoorLockClusterClearAllPinsResponseCallbackBridge * onSuccess
3883         = new CHIPDoorLockClusterClearAllPinsResponseCallbackBridge(completionHandler, [self callbackQueue]);
3884     if (!onSuccess) {
3885         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3886         return;
3887     }
3888
3889     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3890     if (!onFailure) {
3891         delete onSuccess;
3892         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3893         return;
3894     }
3895
3896     CHIP_ERROR err = self.cppCluster.ClearAllPins(onSuccess->Cancel(), onFailure->Cancel());
3897     if (err != CHIP_NO_ERROR) {
3898         delete onSuccess;
3899         delete onFailure;
3900         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3901     }
3902 }
3903 - (void)clearAllRfids:(ResponseHandler)completionHandler
3904 {
3905     CHIPDoorLockClusterClearAllRfidsResponseCallbackBridge * onSuccess
3906         = new CHIPDoorLockClusterClearAllRfidsResponseCallbackBridge(completionHandler, [self callbackQueue]);
3907     if (!onSuccess) {
3908         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3909         return;
3910     }
3911
3912     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3913     if (!onFailure) {
3914         delete onSuccess;
3915         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3916         return;
3917     }
3918
3919     CHIP_ERROR err = self.cppCluster.ClearAllRfids(onSuccess->Cancel(), onFailure->Cancel());
3920     if (err != CHIP_NO_ERROR) {
3921         delete onSuccess;
3922         delete onFailure;
3923         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3924     }
3925 }
3926 - (void)clearHolidaySchedule:(uint8_t)scheduleId completionHandler:(ResponseHandler)completionHandler
3927 {
3928     CHIPDoorLockClusterClearHolidayScheduleResponseCallbackBridge * onSuccess
3929         = new CHIPDoorLockClusterClearHolidayScheduleResponseCallbackBridge(completionHandler, [self callbackQueue]);
3930     if (!onSuccess) {
3931         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3932         return;
3933     }
3934
3935     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3936     if (!onFailure) {
3937         delete onSuccess;
3938         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3939         return;
3940     }
3941
3942     CHIP_ERROR err = self.cppCluster.ClearHolidaySchedule(onSuccess->Cancel(), onFailure->Cancel(), scheduleId);
3943     if (err != CHIP_NO_ERROR) {
3944         delete onSuccess;
3945         delete onFailure;
3946         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3947     }
3948 }
3949 - (void)clearPin:(uint16_t)userId completionHandler:(ResponseHandler)completionHandler
3950 {
3951     CHIPDoorLockClusterClearPinResponseCallbackBridge * onSuccess
3952         = new CHIPDoorLockClusterClearPinResponseCallbackBridge(completionHandler, [self callbackQueue]);
3953     if (!onSuccess) {
3954         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3955         return;
3956     }
3957
3958     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3959     if (!onFailure) {
3960         delete onSuccess;
3961         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3962         return;
3963     }
3964
3965     CHIP_ERROR err = self.cppCluster.ClearPin(onSuccess->Cancel(), onFailure->Cancel(), userId);
3966     if (err != CHIP_NO_ERROR) {
3967         delete onSuccess;
3968         delete onFailure;
3969         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3970     }
3971 }
3972 - (void)clearRfid:(uint16_t)userId completionHandler:(ResponseHandler)completionHandler
3973 {
3974     CHIPDoorLockClusterClearRfidResponseCallbackBridge * onSuccess
3975         = new CHIPDoorLockClusterClearRfidResponseCallbackBridge(completionHandler, [self callbackQueue]);
3976     if (!onSuccess) {
3977         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3978         return;
3979     }
3980
3981     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
3982     if (!onFailure) {
3983         delete onSuccess;
3984         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
3985         return;
3986     }
3987
3988     CHIP_ERROR err = self.cppCluster.ClearRfid(onSuccess->Cancel(), onFailure->Cancel(), userId);
3989     if (err != CHIP_NO_ERROR) {
3990         delete onSuccess;
3991         delete onFailure;
3992         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
3993     }
3994 }
3995 - (void)clearWeekdaySchedule:(uint8_t)scheduleId userId:(uint16_t)userId completionHandler:(ResponseHandler)completionHandler
3996 {
3997     CHIPDoorLockClusterClearWeekdayScheduleResponseCallbackBridge * onSuccess
3998         = new CHIPDoorLockClusterClearWeekdayScheduleResponseCallbackBridge(completionHandler, [self callbackQueue]);
3999     if (!onSuccess) {
4000         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4001         return;
4002     }
4003
4004     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4005     if (!onFailure) {
4006         delete onSuccess;
4007         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4008         return;
4009     }
4010
4011     CHIP_ERROR err = self.cppCluster.ClearWeekdaySchedule(onSuccess->Cancel(), onFailure->Cancel(), scheduleId, userId);
4012     if (err != CHIP_NO_ERROR) {
4013         delete onSuccess;
4014         delete onFailure;
4015         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4016     }
4017 }
4018 - (void)clearYeardaySchedule:(uint8_t)scheduleId userId:(uint16_t)userId completionHandler:(ResponseHandler)completionHandler
4019 {
4020     CHIPDoorLockClusterClearYeardayScheduleResponseCallbackBridge * onSuccess
4021         = new CHIPDoorLockClusterClearYeardayScheduleResponseCallbackBridge(completionHandler, [self callbackQueue]);
4022     if (!onSuccess) {
4023         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4024         return;
4025     }
4026
4027     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4028     if (!onFailure) {
4029         delete onSuccess;
4030         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4031         return;
4032     }
4033
4034     CHIP_ERROR err = self.cppCluster.ClearYeardaySchedule(onSuccess->Cancel(), onFailure->Cancel(), scheduleId, userId);
4035     if (err != CHIP_NO_ERROR) {
4036         delete onSuccess;
4037         delete onFailure;
4038         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4039     }
4040 }
4041 - (void)getHolidaySchedule:(uint8_t)scheduleId completionHandler:(ResponseHandler)completionHandler
4042 {
4043     CHIPDoorLockClusterGetHolidayScheduleResponseCallbackBridge * onSuccess
4044         = new CHIPDoorLockClusterGetHolidayScheduleResponseCallbackBridge(completionHandler, [self callbackQueue]);
4045     if (!onSuccess) {
4046         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4047         return;
4048     }
4049
4050     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4051     if (!onFailure) {
4052         delete onSuccess;
4053         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4054         return;
4055     }
4056
4057     CHIP_ERROR err = self.cppCluster.GetHolidaySchedule(onSuccess->Cancel(), onFailure->Cancel(), scheduleId);
4058     if (err != CHIP_NO_ERROR) {
4059         delete onSuccess;
4060         delete onFailure;
4061         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4062     }
4063 }
4064 - (void)getLogRecord:(uint16_t)logIndex completionHandler:(ResponseHandler)completionHandler
4065 {
4066     CHIPDoorLockClusterGetLogRecordResponseCallbackBridge * onSuccess
4067         = new CHIPDoorLockClusterGetLogRecordResponseCallbackBridge(completionHandler, [self callbackQueue]);
4068     if (!onSuccess) {
4069         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4070         return;
4071     }
4072
4073     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4074     if (!onFailure) {
4075         delete onSuccess;
4076         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4077         return;
4078     }
4079
4080     CHIP_ERROR err = self.cppCluster.GetLogRecord(onSuccess->Cancel(), onFailure->Cancel(), logIndex);
4081     if (err != CHIP_NO_ERROR) {
4082         delete onSuccess;
4083         delete onFailure;
4084         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4085     }
4086 }
4087 - (void)getPin:(uint16_t)userId completionHandler:(ResponseHandler)completionHandler
4088 {
4089     CHIPDoorLockClusterGetPinResponseCallbackBridge * onSuccess
4090         = new CHIPDoorLockClusterGetPinResponseCallbackBridge(completionHandler, [self callbackQueue]);
4091     if (!onSuccess) {
4092         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4093         return;
4094     }
4095
4096     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4097     if (!onFailure) {
4098         delete onSuccess;
4099         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4100         return;
4101     }
4102
4103     CHIP_ERROR err = self.cppCluster.GetPin(onSuccess->Cancel(), onFailure->Cancel(), userId);
4104     if (err != CHIP_NO_ERROR) {
4105         delete onSuccess;
4106         delete onFailure;
4107         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4108     }
4109 }
4110 - (void)getRfid:(uint16_t)userId completionHandler:(ResponseHandler)completionHandler
4111 {
4112     CHIPDoorLockClusterGetRfidResponseCallbackBridge * onSuccess
4113         = new CHIPDoorLockClusterGetRfidResponseCallbackBridge(completionHandler, [self callbackQueue]);
4114     if (!onSuccess) {
4115         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4116         return;
4117     }
4118
4119     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4120     if (!onFailure) {
4121         delete onSuccess;
4122         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4123         return;
4124     }
4125
4126     CHIP_ERROR err = self.cppCluster.GetRfid(onSuccess->Cancel(), onFailure->Cancel(), userId);
4127     if (err != CHIP_NO_ERROR) {
4128         delete onSuccess;
4129         delete onFailure;
4130         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4131     }
4132 }
4133 - (void)getUserType:(uint16_t)userId completionHandler:(ResponseHandler)completionHandler
4134 {
4135     CHIPDoorLockClusterGetUserTypeResponseCallbackBridge * onSuccess
4136         = new CHIPDoorLockClusterGetUserTypeResponseCallbackBridge(completionHandler, [self callbackQueue]);
4137     if (!onSuccess) {
4138         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4139         return;
4140     }
4141
4142     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4143     if (!onFailure) {
4144         delete onSuccess;
4145         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4146         return;
4147     }
4148
4149     CHIP_ERROR err = self.cppCluster.GetUserType(onSuccess->Cancel(), onFailure->Cancel(), userId);
4150     if (err != CHIP_NO_ERROR) {
4151         delete onSuccess;
4152         delete onFailure;
4153         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4154     }
4155 }
4156 - (void)getWeekdaySchedule:(uint8_t)scheduleId userId:(uint16_t)userId completionHandler:(ResponseHandler)completionHandler
4157 {
4158     CHIPDoorLockClusterGetWeekdayScheduleResponseCallbackBridge * onSuccess
4159         = new CHIPDoorLockClusterGetWeekdayScheduleResponseCallbackBridge(completionHandler, [self callbackQueue]);
4160     if (!onSuccess) {
4161         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4162         return;
4163     }
4164
4165     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4166     if (!onFailure) {
4167         delete onSuccess;
4168         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4169         return;
4170     }
4171
4172     CHIP_ERROR err = self.cppCluster.GetWeekdaySchedule(onSuccess->Cancel(), onFailure->Cancel(), scheduleId, userId);
4173     if (err != CHIP_NO_ERROR) {
4174         delete onSuccess;
4175         delete onFailure;
4176         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4177     }
4178 }
4179 - (void)getYeardaySchedule:(uint8_t)scheduleId userId:(uint16_t)userId completionHandler:(ResponseHandler)completionHandler
4180 {
4181     CHIPDoorLockClusterGetYeardayScheduleResponseCallbackBridge * onSuccess
4182         = new CHIPDoorLockClusterGetYeardayScheduleResponseCallbackBridge(completionHandler, [self callbackQueue]);
4183     if (!onSuccess) {
4184         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4185         return;
4186     }
4187
4188     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4189     if (!onFailure) {
4190         delete onSuccess;
4191         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4192         return;
4193     }
4194
4195     CHIP_ERROR err = self.cppCluster.GetYeardaySchedule(onSuccess->Cancel(), onFailure->Cancel(), scheduleId, userId);
4196     if (err != CHIP_NO_ERROR) {
4197         delete onSuccess;
4198         delete onFailure;
4199         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4200     }
4201 }
4202 - (void)lockDoor:(char *)pin completionHandler:(ResponseHandler)completionHandler
4203 {
4204     CHIPDoorLockClusterLockDoorResponseCallbackBridge * onSuccess
4205         = new CHIPDoorLockClusterLockDoorResponseCallbackBridge(completionHandler, [self callbackQueue]);
4206     if (!onSuccess) {
4207         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4208         return;
4209     }
4210
4211     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4212     if (!onFailure) {
4213         delete onSuccess;
4214         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4215         return;
4216     }
4217
4218     CHIP_ERROR err = self.cppCluster.LockDoor(onSuccess->Cancel(), onFailure->Cancel(), pin);
4219     if (err != CHIP_NO_ERROR) {
4220         delete onSuccess;
4221         delete onFailure;
4222         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4223     }
4224 }
4225 - (void)setHolidaySchedule:(uint8_t)scheduleId
4226                 localStartTime:(uint32_t)localStartTime
4227                   localEndTime:(uint32_t)localEndTime
4228     operatingModeDuringHoliday:(uint8_t)operatingModeDuringHoliday
4229              completionHandler:(ResponseHandler)completionHandler
4230 {
4231     CHIPDoorLockClusterSetHolidayScheduleResponseCallbackBridge * onSuccess
4232         = new CHIPDoorLockClusterSetHolidayScheduleResponseCallbackBridge(completionHandler, [self callbackQueue]);
4233     if (!onSuccess) {
4234         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4235         return;
4236     }
4237
4238     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4239     if (!onFailure) {
4240         delete onSuccess;
4241         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4242         return;
4243     }
4244
4245     CHIP_ERROR err = self.cppCluster.SetHolidaySchedule(
4246         onSuccess->Cancel(), onFailure->Cancel(), scheduleId, localStartTime, localEndTime, operatingModeDuringHoliday);
4247     if (err != CHIP_NO_ERROR) {
4248         delete onSuccess;
4249         delete onFailure;
4250         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4251     }
4252 }
4253 - (void)setPin:(uint16_t)userId
4254            userStatus:(uint8_t)userStatus
4255              userType:(uint8_t)userType
4256                   pin:(char *)pin
4257     completionHandler:(ResponseHandler)completionHandler
4258 {
4259     CHIPDoorLockClusterSetPinResponseCallbackBridge * onSuccess
4260         = new CHIPDoorLockClusterSetPinResponseCallbackBridge(completionHandler, [self callbackQueue]);
4261     if (!onSuccess) {
4262         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4263         return;
4264     }
4265
4266     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4267     if (!onFailure) {
4268         delete onSuccess;
4269         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4270         return;
4271     }
4272
4273     CHIP_ERROR err = self.cppCluster.SetPin(onSuccess->Cancel(), onFailure->Cancel(), userId, userStatus, userType, pin);
4274     if (err != CHIP_NO_ERROR) {
4275         delete onSuccess;
4276         delete onFailure;
4277         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4278     }
4279 }
4280 - (void)setRfid:(uint16_t)userId
4281            userStatus:(uint8_t)userStatus
4282              userType:(uint8_t)userType
4283                    id:(char *)id
4284     completionHandler:(ResponseHandler)completionHandler
4285 {
4286     CHIPDoorLockClusterSetRfidResponseCallbackBridge * onSuccess
4287         = new CHIPDoorLockClusterSetRfidResponseCallbackBridge(completionHandler, [self callbackQueue]);
4288     if (!onSuccess) {
4289         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4290         return;
4291     }
4292
4293     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4294     if (!onFailure) {
4295         delete onSuccess;
4296         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4297         return;
4298     }
4299
4300     CHIP_ERROR err = self.cppCluster.SetRfid(onSuccess->Cancel(), onFailure->Cancel(), userId, userStatus, userType, id);
4301     if (err != CHIP_NO_ERROR) {
4302         delete onSuccess;
4303         delete onFailure;
4304         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4305     }
4306 }
4307 - (void)setUserType:(uint16_t)userId userType:(uint8_t)userType completionHandler:(ResponseHandler)completionHandler
4308 {
4309     CHIPDoorLockClusterSetUserTypeResponseCallbackBridge * onSuccess
4310         = new CHIPDoorLockClusterSetUserTypeResponseCallbackBridge(completionHandler, [self callbackQueue]);
4311     if (!onSuccess) {
4312         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4313         return;
4314     }
4315
4316     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4317     if (!onFailure) {
4318         delete onSuccess;
4319         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4320         return;
4321     }
4322
4323     CHIP_ERROR err = self.cppCluster.SetUserType(onSuccess->Cancel(), onFailure->Cancel(), userId, userType);
4324     if (err != CHIP_NO_ERROR) {
4325         delete onSuccess;
4326         delete onFailure;
4327         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4328     }
4329 }
4330 - (void)setWeekdaySchedule:(uint8_t)scheduleId
4331                     userId:(uint16_t)userId
4332                   daysMask:(uint8_t)daysMask
4333                  startHour:(uint8_t)startHour
4334                startMinute:(uint8_t)startMinute
4335                    endHour:(uint8_t)endHour
4336                  endMinute:(uint8_t)endMinute
4337          completionHandler:(ResponseHandler)completionHandler
4338 {
4339     CHIPDoorLockClusterSetWeekdayScheduleResponseCallbackBridge * onSuccess
4340         = new CHIPDoorLockClusterSetWeekdayScheduleResponseCallbackBridge(completionHandler, [self callbackQueue]);
4341     if (!onSuccess) {
4342         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4343         return;
4344     }
4345
4346     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4347     if (!onFailure) {
4348         delete onSuccess;
4349         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4350         return;
4351     }
4352
4353     CHIP_ERROR err = self.cppCluster.SetWeekdaySchedule(
4354         onSuccess->Cancel(), onFailure->Cancel(), scheduleId, userId, daysMask, startHour, startMinute, endHour, endMinute);
4355     if (err != CHIP_NO_ERROR) {
4356         delete onSuccess;
4357         delete onFailure;
4358         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4359     }
4360 }
4361 - (void)setYeardaySchedule:(uint8_t)scheduleId
4362                     userId:(uint16_t)userId
4363             localStartTime:(uint32_t)localStartTime
4364               localEndTime:(uint32_t)localEndTime
4365          completionHandler:(ResponseHandler)completionHandler
4366 {
4367     CHIPDoorLockClusterSetYeardayScheduleResponseCallbackBridge * onSuccess
4368         = new CHIPDoorLockClusterSetYeardayScheduleResponseCallbackBridge(completionHandler, [self callbackQueue]);
4369     if (!onSuccess) {
4370         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4371         return;
4372     }
4373
4374     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4375     if (!onFailure) {
4376         delete onSuccess;
4377         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4378         return;
4379     }
4380
4381     CHIP_ERROR err = self.cppCluster.SetYeardaySchedule(
4382         onSuccess->Cancel(), onFailure->Cancel(), scheduleId, userId, localStartTime, localEndTime);
4383     if (err != CHIP_NO_ERROR) {
4384         delete onSuccess;
4385         delete onFailure;
4386         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4387     }
4388 }
4389 - (void)unlockDoor:(char *)pin completionHandler:(ResponseHandler)completionHandler
4390 {
4391     CHIPDoorLockClusterUnlockDoorResponseCallbackBridge * onSuccess
4392         = new CHIPDoorLockClusterUnlockDoorResponseCallbackBridge(completionHandler, [self callbackQueue]);
4393     if (!onSuccess) {
4394         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4395         return;
4396     }
4397
4398     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4399     if (!onFailure) {
4400         delete onSuccess;
4401         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4402         return;
4403     }
4404
4405     CHIP_ERROR err = self.cppCluster.UnlockDoor(onSuccess->Cancel(), onFailure->Cancel(), pin);
4406     if (err != CHIP_NO_ERROR) {
4407         delete onSuccess;
4408         delete onFailure;
4409         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4410     }
4411 }
4412 - (void)unlockWithTimeout:(uint16_t)timeoutInSeconds pin:(char *)pin completionHandler:(ResponseHandler)completionHandler
4413 {
4414     CHIPDoorLockClusterUnlockWithTimeoutResponseCallbackBridge * onSuccess
4415         = new CHIPDoorLockClusterUnlockWithTimeoutResponseCallbackBridge(completionHandler, [self callbackQueue]);
4416     if (!onSuccess) {
4417         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4418         return;
4419     }
4420
4421     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4422     if (!onFailure) {
4423         delete onSuccess;
4424         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4425         return;
4426     }
4427
4428     CHIP_ERROR err = self.cppCluster.UnlockWithTimeout(onSuccess->Cancel(), onFailure->Cancel(), timeoutInSeconds, pin);
4429     if (err != CHIP_NO_ERROR) {
4430         delete onSuccess;
4431         delete onFailure;
4432         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4433     }
4434 }
4435
4436 - (void)readAttributeLockState:(ResponseHandler)completionHandler
4437 {
4438     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
4439     if (!onSuccess) {
4440         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4441         return;
4442     }
4443
4444     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4445     if (!onFailure) {
4446         delete onSuccess;
4447         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4448         return;
4449     }
4450
4451     CHIP_ERROR err = self.cppCluster.ReadAttributeLockState(onSuccess->Cancel(), onFailure->Cancel());
4452     if (err != CHIP_NO_ERROR) {
4453         delete onSuccess;
4454         delete onFailure;
4455         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4456     }
4457 }
4458
4459 - (void)configureAttributeLockState:(uint16_t)minInterval
4460                         maxInterval:(uint16_t)maxInterval
4461                   completionHandler:(ResponseHandler)completionHandler
4462 {
4463     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
4464     if (!onSuccess) {
4465         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4466         return;
4467     }
4468
4469     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4470     if (!onFailure) {
4471         delete onSuccess;
4472         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4473         return;
4474     }
4475
4476     CHIP_ERROR err
4477         = self.cppCluster.ConfigureAttributeLockState(onSuccess->Cancel(), onFailure->Cancel(), minInterval, maxInterval);
4478     if (err != CHIP_NO_ERROR) {
4479         delete onSuccess;
4480         delete onFailure;
4481         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4482     }
4483 }
4484
4485 - (void)reportAttributeLockState:(ResponseHandler)reportHandler
4486 {
4487     CHIPInt8uAttributeCallbackBridge * onReport = new CHIPInt8uAttributeCallbackBridge(reportHandler, [self callbackQueue], true);
4488     if (!onReport) {
4489         reportHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4490         return;
4491     }
4492
4493     CHIP_ERROR err = self.cppCluster.ReportAttributeLockState(onReport->Cancel());
4494     if (err != CHIP_NO_ERROR) {
4495         delete onReport;
4496         reportHandler([CHIPError errorForCHIPErrorCode:err], nil);
4497     }
4498 }
4499
4500 - (void)readAttributeLockType:(ResponseHandler)completionHandler
4501 {
4502     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
4503     if (!onSuccess) {
4504         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4505         return;
4506     }
4507
4508     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4509     if (!onFailure) {
4510         delete onSuccess;
4511         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4512         return;
4513     }
4514
4515     CHIP_ERROR err = self.cppCluster.ReadAttributeLockType(onSuccess->Cancel(), onFailure->Cancel());
4516     if (err != CHIP_NO_ERROR) {
4517         delete onSuccess;
4518         delete onFailure;
4519         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4520     }
4521 }
4522
4523 - (void)readAttributeActuatorEnabled:(ResponseHandler)completionHandler
4524 {
4525     CHIPBooleanAttributeCallbackBridge * onSuccess
4526         = new CHIPBooleanAttributeCallbackBridge(completionHandler, [self callbackQueue]);
4527     if (!onSuccess) {
4528         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4529         return;
4530     }
4531
4532     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4533     if (!onFailure) {
4534         delete onSuccess;
4535         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4536         return;
4537     }
4538
4539     CHIP_ERROR err = self.cppCluster.ReadAttributeActuatorEnabled(onSuccess->Cancel(), onFailure->Cancel());
4540     if (err != CHIP_NO_ERROR) {
4541         delete onSuccess;
4542         delete onFailure;
4543         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4544     }
4545 }
4546
4547 - (void)readAttributeClusterRevision:(ResponseHandler)completionHandler
4548 {
4549     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
4550     if (!onSuccess) {
4551         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4552         return;
4553     }
4554
4555     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4556     if (!onFailure) {
4557         delete onSuccess;
4558         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4559         return;
4560     }
4561
4562     CHIP_ERROR err = self.cppCluster.ReadAttributeClusterRevision(onSuccess->Cancel(), onFailure->Cancel());
4563     if (err != CHIP_NO_ERROR) {
4564         delete onSuccess;
4565         delete onFailure;
4566         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4567     }
4568 }
4569
4570 @end
4571
4572 @interface CHIPGroups ()
4573 @property (readonly) Controller::GroupsCluster cppCluster;
4574 @end
4575
4576 @implementation CHIPGroups
4577
4578 - (Controller::ClusterBase *)getCluster
4579 {
4580     return &_cppCluster;
4581 }
4582
4583 - (void)addGroup:(uint16_t)groupId groupName:(char *)groupName completionHandler:(ResponseHandler)completionHandler
4584 {
4585     CHIPGroupsClusterAddGroupResponseCallbackBridge * onSuccess
4586         = new CHIPGroupsClusterAddGroupResponseCallbackBridge(completionHandler, [self callbackQueue]);
4587     if (!onSuccess) {
4588         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4589         return;
4590     }
4591
4592     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4593     if (!onFailure) {
4594         delete onSuccess;
4595         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4596         return;
4597     }
4598
4599     CHIP_ERROR err = self.cppCluster.AddGroup(onSuccess->Cancel(), onFailure->Cancel(), groupId, groupName);
4600     if (err != CHIP_NO_ERROR) {
4601         delete onSuccess;
4602         delete onFailure;
4603         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4604     }
4605 }
4606 - (void)addGroupIfIdentifying:(uint16_t)groupId groupName:(char *)groupName completionHandler:(ResponseHandler)completionHandler
4607 {
4608     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
4609     if (!onSuccess) {
4610         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4611         return;
4612     }
4613
4614     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4615     if (!onFailure) {
4616         delete onSuccess;
4617         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4618         return;
4619     }
4620
4621     CHIP_ERROR err = self.cppCluster.AddGroupIfIdentifying(onSuccess->Cancel(), onFailure->Cancel(), groupId, groupName);
4622     if (err != CHIP_NO_ERROR) {
4623         delete onSuccess;
4624         delete onFailure;
4625         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4626     }
4627 }
4628 - (void)getGroupMembership:(uint8_t)groupCount groupList:(uint16_t)groupList completionHandler:(ResponseHandler)completionHandler
4629 {
4630     CHIPGroupsClusterGetGroupMembershipResponseCallbackBridge * onSuccess
4631         = new CHIPGroupsClusterGetGroupMembershipResponseCallbackBridge(completionHandler, [self callbackQueue]);
4632     if (!onSuccess) {
4633         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4634         return;
4635     }
4636
4637     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4638     if (!onFailure) {
4639         delete onSuccess;
4640         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4641         return;
4642     }
4643
4644     CHIP_ERROR err = self.cppCluster.GetGroupMembership(onSuccess->Cancel(), onFailure->Cancel(), groupCount, groupList);
4645     if (err != CHIP_NO_ERROR) {
4646         delete onSuccess;
4647         delete onFailure;
4648         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4649     }
4650 }
4651 - (void)removeAllGroups:(ResponseHandler)completionHandler
4652 {
4653     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
4654     if (!onSuccess) {
4655         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4656         return;
4657     }
4658
4659     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4660     if (!onFailure) {
4661         delete onSuccess;
4662         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4663         return;
4664     }
4665
4666     CHIP_ERROR err = self.cppCluster.RemoveAllGroups(onSuccess->Cancel(), onFailure->Cancel());
4667     if (err != CHIP_NO_ERROR) {
4668         delete onSuccess;
4669         delete onFailure;
4670         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4671     }
4672 }
4673 - (void)removeGroup:(uint16_t)groupId completionHandler:(ResponseHandler)completionHandler
4674 {
4675     CHIPGroupsClusterRemoveGroupResponseCallbackBridge * onSuccess
4676         = new CHIPGroupsClusterRemoveGroupResponseCallbackBridge(completionHandler, [self callbackQueue]);
4677     if (!onSuccess) {
4678         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4679         return;
4680     }
4681
4682     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4683     if (!onFailure) {
4684         delete onSuccess;
4685         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4686         return;
4687     }
4688
4689     CHIP_ERROR err = self.cppCluster.RemoveGroup(onSuccess->Cancel(), onFailure->Cancel(), groupId);
4690     if (err != CHIP_NO_ERROR) {
4691         delete onSuccess;
4692         delete onFailure;
4693         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4694     }
4695 }
4696 - (void)viewGroup:(uint16_t)groupId completionHandler:(ResponseHandler)completionHandler
4697 {
4698     CHIPGroupsClusterViewGroupResponseCallbackBridge * onSuccess
4699         = new CHIPGroupsClusterViewGroupResponseCallbackBridge(completionHandler, [self callbackQueue]);
4700     if (!onSuccess) {
4701         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4702         return;
4703     }
4704
4705     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4706     if (!onFailure) {
4707         delete onSuccess;
4708         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4709         return;
4710     }
4711
4712     CHIP_ERROR err = self.cppCluster.ViewGroup(onSuccess->Cancel(), onFailure->Cancel(), groupId);
4713     if (err != CHIP_NO_ERROR) {
4714         delete onSuccess;
4715         delete onFailure;
4716         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4717     }
4718 }
4719
4720 - (void)readAttributeNameSupport:(ResponseHandler)completionHandler
4721 {
4722     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
4723     if (!onSuccess) {
4724         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4725         return;
4726     }
4727
4728     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4729     if (!onFailure) {
4730         delete onSuccess;
4731         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4732         return;
4733     }
4734
4735     CHIP_ERROR err = self.cppCluster.ReadAttributeNameSupport(onSuccess->Cancel(), onFailure->Cancel());
4736     if (err != CHIP_NO_ERROR) {
4737         delete onSuccess;
4738         delete onFailure;
4739         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4740     }
4741 }
4742
4743 - (void)readAttributeClusterRevision:(ResponseHandler)completionHandler
4744 {
4745     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
4746     if (!onSuccess) {
4747         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4748         return;
4749     }
4750
4751     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4752     if (!onFailure) {
4753         delete onSuccess;
4754         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4755         return;
4756     }
4757
4758     CHIP_ERROR err = self.cppCluster.ReadAttributeClusterRevision(onSuccess->Cancel(), onFailure->Cancel());
4759     if (err != CHIP_NO_ERROR) {
4760         delete onSuccess;
4761         delete onFailure;
4762         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4763     }
4764 }
4765
4766 @end
4767
4768 @interface CHIPIdentify ()
4769 @property (readonly) Controller::IdentifyCluster cppCluster;
4770 @end
4771
4772 @implementation CHIPIdentify
4773
4774 - (Controller::ClusterBase *)getCluster
4775 {
4776     return &_cppCluster;
4777 }
4778
4779 - (void)identify:(uint16_t)identifyTime completionHandler:(ResponseHandler)completionHandler
4780 {
4781     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
4782     if (!onSuccess) {
4783         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4784         return;
4785     }
4786
4787     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4788     if (!onFailure) {
4789         delete onSuccess;
4790         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4791         return;
4792     }
4793
4794     CHIP_ERROR err = self.cppCluster.Identify(onSuccess->Cancel(), onFailure->Cancel(), identifyTime);
4795     if (err != CHIP_NO_ERROR) {
4796         delete onSuccess;
4797         delete onFailure;
4798         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4799     }
4800 }
4801 - (void)identifyQuery:(ResponseHandler)completionHandler
4802 {
4803     CHIPIdentifyClusterIdentifyQueryResponseCallbackBridge * onSuccess
4804         = new CHIPIdentifyClusterIdentifyQueryResponseCallbackBridge(completionHandler, [self callbackQueue]);
4805     if (!onSuccess) {
4806         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4807         return;
4808     }
4809
4810     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4811     if (!onFailure) {
4812         delete onSuccess;
4813         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4814         return;
4815     }
4816
4817     CHIP_ERROR err = self.cppCluster.IdentifyQuery(onSuccess->Cancel(), onFailure->Cancel());
4818     if (err != CHIP_NO_ERROR) {
4819         delete onSuccess;
4820         delete onFailure;
4821         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4822     }
4823 }
4824
4825 - (void)readAttributeIdentifyTime:(ResponseHandler)completionHandler
4826 {
4827     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
4828     if (!onSuccess) {
4829         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4830         return;
4831     }
4832
4833     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4834     if (!onFailure) {
4835         delete onSuccess;
4836         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4837         return;
4838     }
4839
4840     CHIP_ERROR err = self.cppCluster.ReadAttributeIdentifyTime(onSuccess->Cancel(), onFailure->Cancel());
4841     if (err != CHIP_NO_ERROR) {
4842         delete onSuccess;
4843         delete onFailure;
4844         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4845     }
4846 }
4847
4848 - (void)writeAttributeIdentifyTime:(uint16_t)value completionHandler:(ResponseHandler)completionHandler
4849 {
4850     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
4851     if (!onSuccess) {
4852         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4853         return;
4854     }
4855
4856     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4857     if (!onFailure) {
4858         delete onSuccess;
4859         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4860         return;
4861     }
4862
4863     CHIP_ERROR err = self.cppCluster.WriteAttributeIdentifyTime(onSuccess->Cancel(), onFailure->Cancel(), value);
4864     if (err != CHIP_NO_ERROR) {
4865         delete onSuccess;
4866         delete onFailure;
4867         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4868     }
4869 }
4870
4871 - (void)readAttributeClusterRevision:(ResponseHandler)completionHandler
4872 {
4873     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
4874     if (!onSuccess) {
4875         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4876         return;
4877     }
4878
4879     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4880     if (!onFailure) {
4881         delete onSuccess;
4882         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4883         return;
4884     }
4885
4886     CHIP_ERROR err = self.cppCluster.ReadAttributeClusterRevision(onSuccess->Cancel(), onFailure->Cancel());
4887     if (err != CHIP_NO_ERROR) {
4888         delete onSuccess;
4889         delete onFailure;
4890         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4891     }
4892 }
4893
4894 @end
4895
4896 @interface CHIPLevelControl ()
4897 @property (readonly) Controller::LevelControlCluster cppCluster;
4898 @end
4899
4900 @implementation CHIPLevelControl
4901
4902 - (Controller::ClusterBase *)getCluster
4903 {
4904     return &_cppCluster;
4905 }
4906
4907 - (void)move:(uint8_t)moveMode
4908                  rate:(uint8_t)rate
4909            optionMask:(uint8_t)optionMask
4910        optionOverride:(uint8_t)optionOverride
4911     completionHandler:(ResponseHandler)completionHandler
4912 {
4913     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
4914     if (!onSuccess) {
4915         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4916         return;
4917     }
4918
4919     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4920     if (!onFailure) {
4921         delete onSuccess;
4922         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4923         return;
4924     }
4925
4926     CHIP_ERROR err = self.cppCluster.Move(onSuccess->Cancel(), onFailure->Cancel(), moveMode, rate, optionMask, optionOverride);
4927     if (err != CHIP_NO_ERROR) {
4928         delete onSuccess;
4929         delete onFailure;
4930         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4931     }
4932 }
4933 - (void)moveToLevel:(uint8_t)level
4934        transitionTime:(uint16_t)transitionTime
4935            optionMask:(uint8_t)optionMask
4936        optionOverride:(uint8_t)optionOverride
4937     completionHandler:(ResponseHandler)completionHandler
4938 {
4939     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
4940     if (!onSuccess) {
4941         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4942         return;
4943     }
4944
4945     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4946     if (!onFailure) {
4947         delete onSuccess;
4948         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4949         return;
4950     }
4951
4952     CHIP_ERROR err
4953         = self.cppCluster.MoveToLevel(onSuccess->Cancel(), onFailure->Cancel(), level, transitionTime, optionMask, optionOverride);
4954     if (err != CHIP_NO_ERROR) {
4955         delete onSuccess;
4956         delete onFailure;
4957         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4958     }
4959 }
4960 - (void)moveToLevelWithOnOff:(uint8_t)level
4961               transitionTime:(uint16_t)transitionTime
4962            completionHandler:(ResponseHandler)completionHandler
4963 {
4964     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
4965     if (!onSuccess) {
4966         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4967         return;
4968     }
4969
4970     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4971     if (!onFailure) {
4972         delete onSuccess;
4973         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4974         return;
4975     }
4976
4977     CHIP_ERROR err = self.cppCluster.MoveToLevelWithOnOff(onSuccess->Cancel(), onFailure->Cancel(), level, transitionTime);
4978     if (err != CHIP_NO_ERROR) {
4979         delete onSuccess;
4980         delete onFailure;
4981         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
4982     }
4983 }
4984 - (void)moveWithOnOff:(uint8_t)moveMode rate:(uint8_t)rate completionHandler:(ResponseHandler)completionHandler
4985 {
4986     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
4987     if (!onSuccess) {
4988         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4989         return;
4990     }
4991
4992     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
4993     if (!onFailure) {
4994         delete onSuccess;
4995         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
4996         return;
4997     }
4998
4999     CHIP_ERROR err = self.cppCluster.MoveWithOnOff(onSuccess->Cancel(), onFailure->Cancel(), moveMode, rate);
5000     if (err != CHIP_NO_ERROR) {
5001         delete onSuccess;
5002         delete onFailure;
5003         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
5004     }
5005 }
5006 - (void)step:(uint8_t)stepMode
5007              stepSize:(uint8_t)stepSize
5008        transitionTime:(uint16_t)transitionTime
5009            optionMask:(uint8_t)optionMask
5010        optionOverride:(uint8_t)optionOverride
5011     completionHandler:(ResponseHandler)completionHandler
5012 {
5013     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
5014     if (!onSuccess) {
5015         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5016         return;
5017     }
5018
5019     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
5020     if (!onFailure) {
5021         delete onSuccess;
5022         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5023         return;
5024     }
5025
5026     CHIP_ERROR err = self.cppCluster.Step(
5027         onSuccess->Cancel(), onFailure->Cancel(), stepMode, stepSize, transitionTime, optionMask, optionOverride);
5028     if (err != CHIP_NO_ERROR) {
5029         delete onSuccess;
5030         delete onFailure;
5031         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
5032     }
5033 }
5034 - (void)stepWithOnOff:(uint8_t)stepMode
5035              stepSize:(uint8_t)stepSize
5036        transitionTime:(uint16_t)transitionTime
5037     completionHandler:(ResponseHandler)completionHandler
5038 {
5039     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
5040     if (!onSuccess) {
5041         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5042         return;
5043     }
5044
5045     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
5046     if (!onFailure) {
5047         delete onSuccess;
5048         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5049         return;
5050     }
5051
5052     CHIP_ERROR err = self.cppCluster.StepWithOnOff(onSuccess->Cancel(), onFailure->Cancel(), stepMode, stepSize, transitionTime);
5053     if (err != CHIP_NO_ERROR) {
5054         delete onSuccess;
5055         delete onFailure;
5056         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
5057     }
5058 }
5059 - (void)stop:(uint8_t)optionMask optionOverride:(uint8_t)optionOverride completionHandler:(ResponseHandler)completionHandler
5060 {
5061     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
5062     if (!onSuccess) {
5063         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5064         return;
5065     }
5066
5067     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
5068     if (!onFailure) {
5069         delete onSuccess;
5070         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5071         return;
5072     }
5073
5074     CHIP_ERROR err = self.cppCluster.Stop(onSuccess->Cancel(), onFailure->Cancel(), optionMask, optionOverride);
5075     if (err != CHIP_NO_ERROR) {
5076         delete onSuccess;
5077         delete onFailure;
5078         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
5079     }
5080 }
5081 - (void)stopWithOnOff:(ResponseHandler)completionHandler
5082 {
5083     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
5084     if (!onSuccess) {
5085         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5086         return;
5087     }
5088
5089     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
5090     if (!onFailure) {
5091         delete onSuccess;
5092         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5093         return;
5094     }
5095
5096     CHIP_ERROR err = self.cppCluster.StopWithOnOff(onSuccess->Cancel(), onFailure->Cancel());
5097     if (err != CHIP_NO_ERROR) {
5098         delete onSuccess;
5099         delete onFailure;
5100         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
5101     }
5102 }
5103
5104 - (void)readAttributeCurrentLevel:(ResponseHandler)completionHandler
5105 {
5106     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
5107     if (!onSuccess) {
5108         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5109         return;
5110     }
5111
5112     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
5113     if (!onFailure) {
5114         delete onSuccess;
5115         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5116         return;
5117     }
5118
5119     CHIP_ERROR err = self.cppCluster.ReadAttributeCurrentLevel(onSuccess->Cancel(), onFailure->Cancel());
5120     if (err != CHIP_NO_ERROR) {
5121         delete onSuccess;
5122         delete onFailure;
5123         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
5124     }
5125 }
5126
5127 - (void)configureAttributeCurrentLevel:(uint16_t)minInterval
5128                            maxInterval:(uint16_t)maxInterval
5129                                 change:(uint8_t)change
5130                      completionHandler:(ResponseHandler)completionHandler
5131 {
5132     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
5133     if (!onSuccess) {
5134         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5135         return;
5136     }
5137
5138     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
5139     if (!onFailure) {
5140         delete onSuccess;
5141         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5142         return;
5143     }
5144
5145     CHIP_ERROR err = self.cppCluster.ConfigureAttributeCurrentLevel(
5146         onSuccess->Cancel(), onFailure->Cancel(), minInterval, maxInterval, change);
5147     if (err != CHIP_NO_ERROR) {
5148         delete onSuccess;
5149         delete onFailure;
5150         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
5151     }
5152 }
5153
5154 - (void)reportAttributeCurrentLevel:(ResponseHandler)reportHandler
5155 {
5156     CHIPInt8uAttributeCallbackBridge * onReport = new CHIPInt8uAttributeCallbackBridge(reportHandler, [self callbackQueue], true);
5157     if (!onReport) {
5158         reportHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5159         return;
5160     }
5161
5162     CHIP_ERROR err = self.cppCluster.ReportAttributeCurrentLevel(onReport->Cancel());
5163     if (err != CHIP_NO_ERROR) {
5164         delete onReport;
5165         reportHandler([CHIPError errorForCHIPErrorCode:err], nil);
5166     }
5167 }
5168
5169 - (void)readAttributeClusterRevision:(ResponseHandler)completionHandler
5170 {
5171     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
5172     if (!onSuccess) {
5173         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5174         return;
5175     }
5176
5177     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
5178     if (!onFailure) {
5179         delete onSuccess;
5180         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5181         return;
5182     }
5183
5184     CHIP_ERROR err = self.cppCluster.ReadAttributeClusterRevision(onSuccess->Cancel(), onFailure->Cancel());
5185     if (err != CHIP_NO_ERROR) {
5186         delete onSuccess;
5187         delete onFailure;
5188         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
5189     }
5190 }
5191
5192 @end
5193
5194 @interface CHIPOnOff ()
5195 @property (readonly) Controller::OnOffCluster cppCluster;
5196 @end
5197
5198 @implementation CHIPOnOff
5199
5200 - (Controller::ClusterBase *)getCluster
5201 {
5202     return &_cppCluster;
5203 }
5204
5205 - (void)off:(ResponseHandler)completionHandler
5206 {
5207     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
5208     if (!onSuccess) {
5209         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5210         return;
5211     }
5212
5213     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
5214     if (!onFailure) {
5215         delete onSuccess;
5216         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5217         return;
5218     }
5219
5220     CHIP_ERROR err = self.cppCluster.Off(onSuccess->Cancel(), onFailure->Cancel());
5221     if (err != CHIP_NO_ERROR) {
5222         delete onSuccess;
5223         delete onFailure;
5224         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
5225     }
5226 }
5227 - (void)on:(ResponseHandler)completionHandler
5228 {
5229     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
5230     if (!onSuccess) {
5231         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5232         return;
5233     }
5234
5235     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
5236     if (!onFailure) {
5237         delete onSuccess;
5238         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5239         return;
5240     }
5241
5242     CHIP_ERROR err = self.cppCluster.On(onSuccess->Cancel(), onFailure->Cancel());
5243     if (err != CHIP_NO_ERROR) {
5244         delete onSuccess;
5245         delete onFailure;
5246         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
5247     }
5248 }
5249 - (void)toggle:(ResponseHandler)completionHandler
5250 {
5251     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
5252     if (!onSuccess) {
5253         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5254         return;
5255     }
5256
5257     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
5258     if (!onFailure) {
5259         delete onSuccess;
5260         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5261         return;
5262     }
5263
5264     CHIP_ERROR err = self.cppCluster.Toggle(onSuccess->Cancel(), onFailure->Cancel());
5265     if (err != CHIP_NO_ERROR) {
5266         delete onSuccess;
5267         delete onFailure;
5268         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
5269     }
5270 }
5271
5272 - (void)readAttributeOnOff:(ResponseHandler)completionHandler
5273 {
5274     CHIPBooleanAttributeCallbackBridge * onSuccess
5275         = new CHIPBooleanAttributeCallbackBridge(completionHandler, [self callbackQueue]);
5276     if (!onSuccess) {
5277         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5278         return;
5279     }
5280
5281     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
5282     if (!onFailure) {
5283         delete onSuccess;
5284         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5285         return;
5286     }
5287
5288     CHIP_ERROR err = self.cppCluster.ReadAttributeOnOff(onSuccess->Cancel(), onFailure->Cancel());
5289     if (err != CHIP_NO_ERROR) {
5290         delete onSuccess;
5291         delete onFailure;
5292         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
5293     }
5294 }
5295
5296 - (void)configureAttributeOnOff:(uint16_t)minInterval
5297                     maxInterval:(uint16_t)maxInterval
5298               completionHandler:(ResponseHandler)completionHandler
5299 {
5300     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
5301     if (!onSuccess) {
5302         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5303         return;
5304     }
5305
5306     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
5307     if (!onFailure) {
5308         delete onSuccess;
5309         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5310         return;
5311     }
5312
5313     CHIP_ERROR err = self.cppCluster.ConfigureAttributeOnOff(onSuccess->Cancel(), onFailure->Cancel(), minInterval, maxInterval);
5314     if (err != CHIP_NO_ERROR) {
5315         delete onSuccess;
5316         delete onFailure;
5317         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
5318     }
5319 }
5320
5321 - (void)reportAttributeOnOff:(ResponseHandler)reportHandler
5322 {
5323     CHIPBooleanAttributeCallbackBridge * onReport
5324         = new CHIPBooleanAttributeCallbackBridge(reportHandler, [self callbackQueue], true);
5325     if (!onReport) {
5326         reportHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5327         return;
5328     }
5329
5330     CHIP_ERROR err = self.cppCluster.ReportAttributeOnOff(onReport->Cancel());
5331     if (err != CHIP_NO_ERROR) {
5332         delete onReport;
5333         reportHandler([CHIPError errorForCHIPErrorCode:err], nil);
5334     }
5335 }
5336
5337 - (void)readAttributeClusterRevision:(ResponseHandler)completionHandler
5338 {
5339     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
5340     if (!onSuccess) {
5341         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5342         return;
5343     }
5344
5345     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
5346     if (!onFailure) {
5347         delete onSuccess;
5348         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5349         return;
5350     }
5351
5352     CHIP_ERROR err = self.cppCluster.ReadAttributeClusterRevision(onSuccess->Cancel(), onFailure->Cancel());
5353     if (err != CHIP_NO_ERROR) {
5354         delete onSuccess;
5355         delete onFailure;
5356         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
5357     }
5358 }
5359
5360 @end
5361
5362 @interface CHIPScenes ()
5363 @property (readonly) Controller::ScenesCluster cppCluster;
5364 @end
5365
5366 @implementation CHIPScenes
5367
5368 - (Controller::ClusterBase *)getCluster
5369 {
5370     return &_cppCluster;
5371 }
5372
5373 - (void)addScene:(uint16_t)groupId
5374               sceneId:(uint8_t)sceneId
5375        transitionTime:(uint16_t)transitionTime
5376             sceneName:(char *)sceneName
5377             clusterId:(uint16_t)clusterId
5378                length:(uint8_t)length
5379                 value:(uint8_t)value
5380     completionHandler:(ResponseHandler)completionHandler
5381 {
5382     CHIPScenesClusterAddSceneResponseCallbackBridge * onSuccess
5383         = new CHIPScenesClusterAddSceneResponseCallbackBridge(completionHandler, [self callbackQueue]);
5384     if (!onSuccess) {
5385         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5386         return;
5387     }
5388
5389     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
5390     if (!onFailure) {
5391         delete onSuccess;
5392         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5393         return;
5394     }
5395
5396     CHIP_ERROR err = self.cppCluster.AddScene(
5397         onSuccess->Cancel(), onFailure->Cancel(), groupId, sceneId, transitionTime, sceneName, clusterId, length, value);
5398     if (err != CHIP_NO_ERROR) {
5399         delete onSuccess;
5400         delete onFailure;
5401         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
5402     }
5403 }
5404 - (void)getSceneMembership:(uint16_t)groupId completionHandler:(ResponseHandler)completionHandler
5405 {
5406     CHIPScenesClusterGetSceneMembershipResponseCallbackBridge * onSuccess
5407         = new CHIPScenesClusterGetSceneMembershipResponseCallbackBridge(completionHandler, [self callbackQueue]);
5408     if (!onSuccess) {
5409         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5410         return;
5411     }
5412
5413     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
5414     if (!onFailure) {
5415         delete onSuccess;
5416         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5417         return;
5418     }
5419
5420     CHIP_ERROR err = self.cppCluster.GetSceneMembership(onSuccess->Cancel(), onFailure->Cancel(), groupId);
5421     if (err != CHIP_NO_ERROR) {
5422         delete onSuccess;
5423         delete onFailure;
5424         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
5425     }
5426 }
5427 - (void)recallScene:(uint16_t)groupId
5428               sceneId:(uint8_t)sceneId
5429        transitionTime:(uint16_t)transitionTime
5430     completionHandler:(ResponseHandler)completionHandler
5431 {
5432     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
5433     if (!onSuccess) {
5434         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5435         return;
5436     }
5437
5438     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
5439     if (!onFailure) {
5440         delete onSuccess;
5441         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5442         return;
5443     }
5444
5445     CHIP_ERROR err = self.cppCluster.RecallScene(onSuccess->Cancel(), onFailure->Cancel(), groupId, sceneId, transitionTime);
5446     if (err != CHIP_NO_ERROR) {
5447         delete onSuccess;
5448         delete onFailure;
5449         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
5450     }
5451 }
5452 - (void)removeAllScenes:(uint16_t)groupId completionHandler:(ResponseHandler)completionHandler
5453 {
5454     CHIPScenesClusterRemoveAllScenesResponseCallbackBridge * onSuccess
5455         = new CHIPScenesClusterRemoveAllScenesResponseCallbackBridge(completionHandler, [self callbackQueue]);
5456     if (!onSuccess) {
5457         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5458         return;
5459     }
5460
5461     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
5462     if (!onFailure) {
5463         delete onSuccess;
5464         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5465         return;
5466     }
5467
5468     CHIP_ERROR err = self.cppCluster.RemoveAllScenes(onSuccess->Cancel(), onFailure->Cancel(), groupId);
5469     if (err != CHIP_NO_ERROR) {
5470         delete onSuccess;
5471         delete onFailure;
5472         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
5473     }
5474 }
5475 - (void)removeScene:(uint16_t)groupId sceneId:(uint8_t)sceneId completionHandler:(ResponseHandler)completionHandler
5476 {
5477     CHIPScenesClusterRemoveSceneResponseCallbackBridge * onSuccess
5478         = new CHIPScenesClusterRemoveSceneResponseCallbackBridge(completionHandler, [self callbackQueue]);
5479     if (!onSuccess) {
5480         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5481         return;
5482     }
5483
5484     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
5485     if (!onFailure) {
5486         delete onSuccess;
5487         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5488         return;
5489     }
5490
5491     CHIP_ERROR err = self.cppCluster.RemoveScene(onSuccess->Cancel(), onFailure->Cancel(), groupId, sceneId);
5492     if (err != CHIP_NO_ERROR) {
5493         delete onSuccess;
5494         delete onFailure;
5495         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
5496     }
5497 }
5498 - (void)storeScene:(uint16_t)groupId sceneId:(uint8_t)sceneId completionHandler:(ResponseHandler)completionHandler
5499 {
5500     CHIPScenesClusterStoreSceneResponseCallbackBridge * onSuccess
5501         = new CHIPScenesClusterStoreSceneResponseCallbackBridge(completionHandler, [self callbackQueue]);
5502     if (!onSuccess) {
5503         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5504         return;
5505     }
5506
5507     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
5508     if (!onFailure) {
5509         delete onSuccess;
5510         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5511         return;
5512     }
5513
5514     CHIP_ERROR err = self.cppCluster.StoreScene(onSuccess->Cancel(), onFailure->Cancel(), groupId, sceneId);
5515     if (err != CHIP_NO_ERROR) {
5516         delete onSuccess;
5517         delete onFailure;
5518         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
5519     }
5520 }
5521 - (void)viewScene:(uint16_t)groupId sceneId:(uint8_t)sceneId completionHandler:(ResponseHandler)completionHandler
5522 {
5523     CHIPScenesClusterViewSceneResponseCallbackBridge * onSuccess
5524         = new CHIPScenesClusterViewSceneResponseCallbackBridge(completionHandler, [self callbackQueue]);
5525     if (!onSuccess) {
5526         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5527         return;
5528     }
5529
5530     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
5531     if (!onFailure) {
5532         delete onSuccess;
5533         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5534         return;
5535     }
5536
5537     CHIP_ERROR err = self.cppCluster.ViewScene(onSuccess->Cancel(), onFailure->Cancel(), groupId, sceneId);
5538     if (err != CHIP_NO_ERROR) {
5539         delete onSuccess;
5540         delete onFailure;
5541         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
5542     }
5543 }
5544
5545 - (void)readAttributeSceneCount:(ResponseHandler)completionHandler
5546 {
5547     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
5548     if (!onSuccess) {
5549         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5550         return;
5551     }
5552
5553     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
5554     if (!onFailure) {
5555         delete onSuccess;
5556         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5557         return;
5558     }
5559
5560     CHIP_ERROR err = self.cppCluster.ReadAttributeSceneCount(onSuccess->Cancel(), onFailure->Cancel());
5561     if (err != CHIP_NO_ERROR) {
5562         delete onSuccess;
5563         delete onFailure;
5564         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
5565     }
5566 }
5567
5568 - (void)readAttributeCurrentScene:(ResponseHandler)completionHandler
5569 {
5570     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
5571     if (!onSuccess) {
5572         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5573         return;
5574     }
5575
5576     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
5577     if (!onFailure) {
5578         delete onSuccess;
5579         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5580         return;
5581     }
5582
5583     CHIP_ERROR err = self.cppCluster.ReadAttributeCurrentScene(onSuccess->Cancel(), onFailure->Cancel());
5584     if (err != CHIP_NO_ERROR) {
5585         delete onSuccess;
5586         delete onFailure;
5587         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
5588     }
5589 }
5590
5591 - (void)readAttributeCurrentGroup:(ResponseHandler)completionHandler
5592 {
5593     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
5594     if (!onSuccess) {
5595         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5596         return;
5597     }
5598
5599     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
5600     if (!onFailure) {
5601         delete onSuccess;
5602         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5603         return;
5604     }
5605
5606     CHIP_ERROR err = self.cppCluster.ReadAttributeCurrentGroup(onSuccess->Cancel(), onFailure->Cancel());
5607     if (err != CHIP_NO_ERROR) {
5608         delete onSuccess;
5609         delete onFailure;
5610         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
5611     }
5612 }
5613
5614 - (void)readAttributeSceneValid:(ResponseHandler)completionHandler
5615 {
5616     CHIPBooleanAttributeCallbackBridge * onSuccess
5617         = new CHIPBooleanAttributeCallbackBridge(completionHandler, [self callbackQueue]);
5618     if (!onSuccess) {
5619         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5620         return;
5621     }
5622
5623     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
5624     if (!onFailure) {
5625         delete onSuccess;
5626         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5627         return;
5628     }
5629
5630     CHIP_ERROR err = self.cppCluster.ReadAttributeSceneValid(onSuccess->Cancel(), onFailure->Cancel());
5631     if (err != CHIP_NO_ERROR) {
5632         delete onSuccess;
5633         delete onFailure;
5634         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
5635     }
5636 }
5637
5638 - (void)readAttributeNameSupport:(ResponseHandler)completionHandler
5639 {
5640     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
5641     if (!onSuccess) {
5642         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5643         return;
5644     }
5645
5646     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
5647     if (!onFailure) {
5648         delete onSuccess;
5649         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5650         return;
5651     }
5652
5653     CHIP_ERROR err = self.cppCluster.ReadAttributeNameSupport(onSuccess->Cancel(), onFailure->Cancel());
5654     if (err != CHIP_NO_ERROR) {
5655         delete onSuccess;
5656         delete onFailure;
5657         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
5658     }
5659 }
5660
5661 - (void)readAttributeClusterRevision:(ResponseHandler)completionHandler
5662 {
5663     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
5664     if (!onSuccess) {
5665         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5666         return;
5667     }
5668
5669     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
5670     if (!onFailure) {
5671         delete onSuccess;
5672         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5673         return;
5674     }
5675
5676     CHIP_ERROR err = self.cppCluster.ReadAttributeClusterRevision(onSuccess->Cancel(), onFailure->Cancel());
5677     if (err != CHIP_NO_ERROR) {
5678         delete onSuccess;
5679         delete onFailure;
5680         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
5681     }
5682 }
5683
5684 @end
5685
5686 @interface CHIPTemperatureMeasurement ()
5687 @property (readonly) Controller::TemperatureMeasurementCluster cppCluster;
5688 @end
5689
5690 @implementation CHIPTemperatureMeasurement
5691
5692 - (Controller::ClusterBase *)getCluster
5693 {
5694     return &_cppCluster;
5695 }
5696
5697 - (void)readAttributeMeasuredValue:(ResponseHandler)completionHandler
5698 {
5699     CHIPInt16sAttributeCallbackBridge * onSuccess = new CHIPInt16sAttributeCallbackBridge(completionHandler, [self callbackQueue]);
5700     if (!onSuccess) {
5701         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5702         return;
5703     }
5704
5705     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
5706     if (!onFailure) {
5707         delete onSuccess;
5708         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5709         return;
5710     }
5711
5712     CHIP_ERROR err = self.cppCluster.ReadAttributeMeasuredValue(onSuccess->Cancel(), onFailure->Cancel());
5713     if (err != CHIP_NO_ERROR) {
5714         delete onSuccess;
5715         delete onFailure;
5716         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
5717     }
5718 }
5719
5720 - (void)configureAttributeMeasuredValue:(uint16_t)minInterval
5721                             maxInterval:(uint16_t)maxInterval
5722                                  change:(int16_t)change
5723                       completionHandler:(ResponseHandler)completionHandler
5724 {
5725     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
5726     if (!onSuccess) {
5727         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5728         return;
5729     }
5730
5731     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
5732     if (!onFailure) {
5733         delete onSuccess;
5734         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5735         return;
5736     }
5737
5738     CHIP_ERROR err = self.cppCluster.ConfigureAttributeMeasuredValue(
5739         onSuccess->Cancel(), onFailure->Cancel(), minInterval, maxInterval, change);
5740     if (err != CHIP_NO_ERROR) {
5741         delete onSuccess;
5742         delete onFailure;
5743         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
5744     }
5745 }
5746
5747 - (void)reportAttributeMeasuredValue:(ResponseHandler)reportHandler
5748 {
5749     CHIPInt16sAttributeCallbackBridge * onReport = new CHIPInt16sAttributeCallbackBridge(reportHandler, [self callbackQueue], true);
5750     if (!onReport) {
5751         reportHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5752         return;
5753     }
5754
5755     CHIP_ERROR err = self.cppCluster.ReportAttributeMeasuredValue(onReport->Cancel());
5756     if (err != CHIP_NO_ERROR) {
5757         delete onReport;
5758         reportHandler([CHIPError errorForCHIPErrorCode:err], nil);
5759     }
5760 }
5761
5762 - (void)readAttributeMinMeasuredValue:(ResponseHandler)completionHandler
5763 {
5764     CHIPInt16sAttributeCallbackBridge * onSuccess = new CHIPInt16sAttributeCallbackBridge(completionHandler, [self callbackQueue]);
5765     if (!onSuccess) {
5766         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5767         return;
5768     }
5769
5770     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
5771     if (!onFailure) {
5772         delete onSuccess;
5773         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5774         return;
5775     }
5776
5777     CHIP_ERROR err = self.cppCluster.ReadAttributeMinMeasuredValue(onSuccess->Cancel(), onFailure->Cancel());
5778     if (err != CHIP_NO_ERROR) {
5779         delete onSuccess;
5780         delete onFailure;
5781         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
5782     }
5783 }
5784
5785 - (void)readAttributeMaxMeasuredValue:(ResponseHandler)completionHandler
5786 {
5787     CHIPInt16sAttributeCallbackBridge * onSuccess = new CHIPInt16sAttributeCallbackBridge(completionHandler, [self callbackQueue]);
5788     if (!onSuccess) {
5789         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5790         return;
5791     }
5792
5793     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
5794     if (!onFailure) {
5795         delete onSuccess;
5796         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5797         return;
5798     }
5799
5800     CHIP_ERROR err = self.cppCluster.ReadAttributeMaxMeasuredValue(onSuccess->Cancel(), onFailure->Cancel());
5801     if (err != CHIP_NO_ERROR) {
5802         delete onSuccess;
5803         delete onFailure;
5804         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
5805     }
5806 }
5807
5808 - (void)readAttributeClusterRevision:(ResponseHandler)completionHandler
5809 {
5810     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
5811     if (!onSuccess) {
5812         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5813         return;
5814     }
5815
5816     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
5817     if (!onFailure) {
5818         delete onSuccess;
5819         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
5820         return;
5821     }
5822
5823     CHIP_ERROR err = self.cppCluster.ReadAttributeClusterRevision(onSuccess->Cancel(), onFailure->Cancel());
5824     if (err != CHIP_NO_ERROR) {
5825         delete onSuccess;
5826         delete onFailure;
5827         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
5828     }
5829 }
5830
5831 @end