src/darwin/Framework/CHIP/gen/CHIPClustersObjc.mm

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