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