examples/chip-tool/commands/clusters/Commands.h

   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 #pragma once
  21
  22 #include <cstdint>
  23
  24 #include "ModelCommand.h"
  25 #include "gen/CHIPClientCallbacks.h"
  26 #include <controller/CHIPClusters.h>
  27 #include <lib/core/CHIPSafeCasts.h>
  28
  29 static void OnDefaultSuccessResponse(void * context)
  30 {
  31     ChipLogProgress(chipTool, "Default Success Response");
  32
  33     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
  34     command->SetCommandExitStatus(true);
  35 }
  36
  37 static void OnDefaultFailureResponse(void * context, uint8_t status)
  38 {
  39     ChipLogProgress(chipTool, "Default Failure Response: 0x%02x", status);
  40
  41     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
  42     command->SetCommandExitStatus(false);
  43 }
  44
  45 static void OnBooleanAttributeResponse(void * context, bool value)
  46 {
  47     ChipLogProgress(chipTool, "Boolean attribute Response: %d", value);
  48
  49     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
  50     command->SetCommandExitStatus(true);
  51 }
  52
  53 static void OnInt8uAttributeResponse(void * context, uint8_t value)
  54 {
  55     ChipLogProgress(chipTool, "Int8u attribute Response: %" PRIu8, value);
  56
  57     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
  58     command->SetCommandExitStatus(true);
  59 }
  60
  61 static void OnInt16uAttributeResponse(void * context, uint16_t value)
  62 {
  63     ChipLogProgress(chipTool, "Int16u attribute Response: %" PRIu16, value);
  64
  65     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
  66     command->SetCommandExitStatus(true);
  67 }
  68
  69 static void OnInt32uAttributeResponse(void * context, uint32_t value)
  70 {
  71     ChipLogProgress(chipTool, "Int32u attribute Response: %" PRIu32, value);
  72
  73     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
  74     command->SetCommandExitStatus(true);
  75 }
  76
  77 static void OnInt64uAttributeResponse(void * context, uint64_t value)
  78 {
  79     ChipLogProgress(chipTool, "Int64u attribute Response: %" PRIu64, value);
  80
  81     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
  82     command->SetCommandExitStatus(true);
  83 }
  84
  85 static void OnInt16sAttributeResponse(void * context, int16_t value)
  86 {
  87     ChipLogProgress(chipTool, "Int16s attribute Response: %" PRId16, value);
  88
  89     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
  90     command->SetCommandExitStatus(true);
  91 }
  92
  93 static void OnStringAttributeResponse(void * context, const chip::ByteSpan value)
  94 {
  95     char * str = (char *) malloc(value.size() * sizeof(char));
  96     memmove(str, value.data(), value.size());
  97     str[value.size()] = '\0';
  98     free(str);
  99
 100     ChipLogProgress(chipTool, "String attribute Response: %s (%" PRIu16 ")", str, strlen(str));
 101
 102     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 103     command->SetCommandExitStatus(true);
 104 }
 105
 106 static void OnDoorLockClusterClearAllPinsResponse(void * context)
 107 {
 108     ChipLogProgress(chipTool, "DoorLockClusterClearAllPinsResponse");
 109
 110     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 111     command->SetCommandExitStatus(true);
 112 }
 113
 114 static void OnDoorLockClusterClearAllRfidsResponse(void * context)
 115 {
 116     ChipLogProgress(chipTool, "DoorLockClusterClearAllRfidsResponse");
 117
 118     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 119     command->SetCommandExitStatus(true);
 120 }
 121
 122 static void OnDoorLockClusterClearHolidayScheduleResponse(void * context)
 123 {
 124     ChipLogProgress(chipTool, "DoorLockClusterClearHolidayScheduleResponse");
 125
 126     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 127     command->SetCommandExitStatus(true);
 128 }
 129
 130 static void OnDoorLockClusterClearPinResponse(void * context)
 131 {
 132     ChipLogProgress(chipTool, "DoorLockClusterClearPinResponse");
 133
 134     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 135     command->SetCommandExitStatus(true);
 136 }
 137
 138 static void OnDoorLockClusterClearRfidResponse(void * context)
 139 {
 140     ChipLogProgress(chipTool, "DoorLockClusterClearRfidResponse");
 141
 142     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 143     command->SetCommandExitStatus(true);
 144 }
 145
 146 static void OnDoorLockClusterClearWeekdayScheduleResponse(void * context)
 147 {
 148     ChipLogProgress(chipTool, "DoorLockClusterClearWeekdayScheduleResponse");
 149
 150     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 151     command->SetCommandExitStatus(true);
 152 }
 153
 154 static void OnDoorLockClusterClearYeardayScheduleResponse(void * context)
 155 {
 156     ChipLogProgress(chipTool, "DoorLockClusterClearYeardayScheduleResponse");
 157
 158     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 159     command->SetCommandExitStatus(true);
 160 }
 161
 162 static void OnDoorLockClusterGetHolidayScheduleResponse(void * context, uint8_t scheduleId, uint32_t localStartTime,
 163                                                         uint32_t localEndTime, uint8_t operatingModeDuringHoliday)
 164 {
 165     ChipLogProgress(chipTool, "DoorLockClusterGetHolidayScheduleResponse");
 166
 167     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 168     command->SetCommandExitStatus(true);
 169 }
 170
 171 static void OnDoorLockClusterGetLogRecordResponse(void * context, uint16_t logEntryId, uint32_t timestamp, uint8_t eventType,
 172                                                   uint8_t source, uint8_t eventIdOrAlarmCode, uint16_t userId, uint8_t * pin)
 173 {
 174     ChipLogProgress(chipTool, "DoorLockClusterGetLogRecordResponse");
 175
 176     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 177     command->SetCommandExitStatus(true);
 178 }
 179
 180 static void OnDoorLockClusterGetPinResponse(void * context, uint16_t userId, uint8_t userStatus, uint8_t userType, uint8_t * pin)
 181 {
 182     ChipLogProgress(chipTool, "DoorLockClusterGetPinResponse");
 183
 184     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 185     command->SetCommandExitStatus(true);
 186 }
 187
 188 static void OnDoorLockClusterGetRfidResponse(void * context, uint16_t userId, uint8_t userStatus, uint8_t userType, uint8_t * rfid)
 189 {
 190     ChipLogProgress(chipTool, "DoorLockClusterGetRfidResponse");
 191
 192     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 193     command->SetCommandExitStatus(true);
 194 }
 195
 196 static void OnDoorLockClusterGetUserTypeResponse(void * context, uint16_t userId, uint8_t userType)
 197 {
 198     ChipLogProgress(chipTool, "DoorLockClusterGetUserTypeResponse");
 199
 200     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 201     command->SetCommandExitStatus(true);
 202 }
 203
 204 static void OnDoorLockClusterGetWeekdayScheduleResponse(void * context, uint8_t scheduleId, uint16_t userId, uint8_t daysMask,
 205                                                         uint8_t startHour, uint8_t startMinute, uint8_t endHour, uint8_t endMinute)
 206 {
 207     ChipLogProgress(chipTool, "DoorLockClusterGetWeekdayScheduleResponse");
 208
 209     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 210     command->SetCommandExitStatus(true);
 211 }
 212
 213 static void OnDoorLockClusterGetYeardayScheduleResponse(void * context, uint8_t scheduleId, uint16_t userId,
 214                                                         uint32_t localStartTime, uint32_t localEndTime)
 215 {
 216     ChipLogProgress(chipTool, "DoorLockClusterGetYeardayScheduleResponse");
 217
 218     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 219     command->SetCommandExitStatus(true);
 220 }
 221
 222 static void OnDoorLockClusterLockDoorResponse(void * context)
 223 {
 224     ChipLogProgress(chipTool, "DoorLockClusterLockDoorResponse");
 225
 226     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 227     command->SetCommandExitStatus(true);
 228 }
 229
 230 static void OnDoorLockClusterSetHolidayScheduleResponse(void * context)
 231 {
 232     ChipLogProgress(chipTool, "DoorLockClusterSetHolidayScheduleResponse");
 233
 234     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 235     command->SetCommandExitStatus(true);
 236 }
 237
 238 static void OnDoorLockClusterSetPinResponse(void * context)
 239 {
 240     ChipLogProgress(chipTool, "DoorLockClusterSetPinResponse");
 241
 242     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 243     command->SetCommandExitStatus(true);
 244 }
 245
 246 static void OnDoorLockClusterSetRfidResponse(void * context)
 247 {
 248     ChipLogProgress(chipTool, "DoorLockClusterSetRfidResponse");
 249
 250     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 251     command->SetCommandExitStatus(true);
 252 }
 253
 254 static void OnDoorLockClusterSetUserTypeResponse(void * context)
 255 {
 256     ChipLogProgress(chipTool, "DoorLockClusterSetUserTypeResponse");
 257
 258     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 259     command->SetCommandExitStatus(true);
 260 }
 261
 262 static void OnDoorLockClusterSetWeekdayScheduleResponse(void * context)
 263 {
 264     ChipLogProgress(chipTool, "DoorLockClusterSetWeekdayScheduleResponse");
 265
 266     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 267     command->SetCommandExitStatus(true);
 268 }
 269
 270 static void OnDoorLockClusterSetYeardayScheduleResponse(void * context)
 271 {
 272     ChipLogProgress(chipTool, "DoorLockClusterSetYeardayScheduleResponse");
 273
 274     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 275     command->SetCommandExitStatus(true);
 276 }
 277
 278 static void OnDoorLockClusterUnlockDoorResponse(void * context)
 279 {
 280     ChipLogProgress(chipTool, "DoorLockClusterUnlockDoorResponse");
 281
 282     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 283     command->SetCommandExitStatus(true);
 284 }
 285
 286 static void OnDoorLockClusterUnlockWithTimeoutResponse(void * context)
 287 {
 288     ChipLogProgress(chipTool, "DoorLockClusterUnlockWithTimeoutResponse");
 289
 290     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 291     command->SetCommandExitStatus(true);
 292 }
 293
 294 static void OnGeneralCommissioningClusterArmFailSafeResponse(void * context, uint8_t errorCode, uint8_t * debugText)
 295 {
 296     ChipLogProgress(chipTool, "GeneralCommissioningClusterArmFailSafeResponse");
 297
 298     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 299     command->SetCommandExitStatus(true);
 300 }
 301
 302 static void OnGeneralCommissioningClusterCommissioningCompleteResponse(void * context, uint8_t errorCode, uint8_t * debugText)
 303 {
 304     ChipLogProgress(chipTool, "GeneralCommissioningClusterCommissioningCompleteResponse");
 305
 306     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 307     command->SetCommandExitStatus(true);
 308 }
 309
 310 static void OnGeneralCommissioningClusterSetFabricResponse(void * context, uint8_t errorCode, uint8_t * debugText)
 311 {
 312     ChipLogProgress(chipTool, "GeneralCommissioningClusterSetFabricResponse");
 313
 314     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 315     command->SetCommandExitStatus(true);
 316 }
 317
 318 static void OnGroupsClusterAddGroupResponse(void * context, uint16_t groupId)
 319 {
 320     ChipLogProgress(chipTool, "GroupsClusterAddGroupResponse");
 321
 322     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 323     command->SetCommandExitStatus(true);
 324 }
 325
 326 static void OnGroupsClusterGetGroupMembershipResponse(void * context, uint8_t capacity, uint8_t groupCount,
 327                                                       /* TYPE WARNING: array array defaults to */ uint8_t * groupList)
 328 {
 329     ChipLogProgress(chipTool, "GroupsClusterGetGroupMembershipResponse");
 330
 331     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 332     command->SetCommandExitStatus(true);
 333 }
 334
 335 static void OnGroupsClusterRemoveGroupResponse(void * context, uint16_t groupId)
 336 {
 337     ChipLogProgress(chipTool, "GroupsClusterRemoveGroupResponse");
 338
 339     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 340     command->SetCommandExitStatus(true);
 341 }
 342
 343 static void OnGroupsClusterViewGroupResponse(void * context, uint16_t groupId, uint8_t * groupName)
 344 {
 345     ChipLogProgress(chipTool, "GroupsClusterViewGroupResponse");
 346
 347     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 348     command->SetCommandExitStatus(true);
 349 }
 350
 351 static void OnIdentifyClusterIdentifyQueryResponse(void * context, uint16_t timeout)
 352 {
 353     ChipLogProgress(chipTool, "IdentifyClusterIdentifyQueryResponse");
 354
 355     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 356     command->SetCommandExitStatus(true);
 357 }
 358
 359 static void OnScenesClusterAddSceneResponse(void * context, uint16_t groupId, uint8_t sceneId)
 360 {
 361     ChipLogProgress(chipTool, "ScenesClusterAddSceneResponse");
 362
 363     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 364     command->SetCommandExitStatus(true);
 365 }
 366
 367 static void OnScenesClusterGetSceneMembershipResponse(void * context, uint8_t capacity, uint16_t groupId, uint8_t sceneCount,
 368                                                       /* TYPE WARNING: array array defaults to */ uint8_t * sceneList)
 369 {
 370     ChipLogProgress(chipTool, "ScenesClusterGetSceneMembershipResponse");
 371
 372     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 373     command->SetCommandExitStatus(true);
 374 }
 375
 376 static void OnScenesClusterRemoveAllScenesResponse(void * context, uint16_t groupId)
 377 {
 378     ChipLogProgress(chipTool, "ScenesClusterRemoveAllScenesResponse");
 379
 380     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 381     command->SetCommandExitStatus(true);
 382 }
 383
 384 static void OnScenesClusterRemoveSceneResponse(void * context, uint16_t groupId, uint8_t sceneId)
 385 {
 386     ChipLogProgress(chipTool, "ScenesClusterRemoveSceneResponse");
 387
 388     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 389     command->SetCommandExitStatus(true);
 390 }
 391
 392 static void OnScenesClusterStoreSceneResponse(void * context, uint16_t groupId, uint8_t sceneId)
 393 {
 394     ChipLogProgress(chipTool, "ScenesClusterStoreSceneResponse");
 395
 396     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 397     command->SetCommandExitStatus(true);
 398 }
 399
 400 static void OnScenesClusterViewSceneResponse(void * context, uint16_t groupId, uint8_t sceneId, uint16_t transitionTime,
 401                                              uint8_t * sceneName,
 402                                              /* TYPE WARNING: array array defaults to */ uint8_t * extensionFieldSets)
 403 {
 404     ChipLogProgress(chipTool, "ScenesClusterViewSceneResponse");
 405
 406     ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
 407     command->SetCommandExitStatus(true);
 408 }
 409
 410 /*----------------------------------------------------------------------------*\
 411 | Cluster Name                                                        |   ID   |
 412 |---------------------------------------------------------------------+--------|
 413 | ApplicationBasic                                                    | 0x050D |
 414 | BarrierControl                                                      | 0x0103 |
 415 | Basic                                                               | 0x0028 |
 416 | Binding                                                             | 0xF000 |
 417 | ColorControl                                                        | 0x0300 |
 418 | DoorLock                                                            | 0x0101 |
 419 | GeneralCommissioning                                                | 0x0030 |
 420 | Groups                                                              | 0x0004 |
 421 | Identify                                                            | 0x0003 |
 422 | LevelControl                                                        | 0x0008 |
 423 | LowPower                                                            | 0x0508 |
 424 | OnOff                                                               | 0x0006 |
 425 | Scenes                                                              | 0x0005 |
 426 | TemperatureMeasurement                                              | 0x0402 |
 427 \*----------------------------------------------------------------------------*/
 428
 429 constexpr chip::ClusterId kApplicationBasicClusterId       = 0x050D;
 430 constexpr chip::ClusterId kBarrierControlClusterId         = 0x0103;
 431 constexpr chip::ClusterId kBasicClusterId                  = 0x0028;
 432 constexpr chip::ClusterId kBindingClusterId                = 0xF000;
 433 constexpr chip::ClusterId kColorControlClusterId           = 0x0300;
 434 constexpr chip::ClusterId kDoorLockClusterId               = 0x0101;
 435 constexpr chip::ClusterId kGeneralCommissioningClusterId   = 0x0030;
 436 constexpr chip::ClusterId kGroupsClusterId                 = 0x0004;
 437 constexpr chip::ClusterId kIdentifyClusterId               = 0x0003;
 438 constexpr chip::ClusterId kLevelControlClusterId           = 0x0008;
 439 constexpr chip::ClusterId kLowPowerClusterId               = 0x0508;
 440 constexpr chip::ClusterId kOnOffClusterId                  = 0x0006;
 441 constexpr chip::ClusterId kScenesClusterId                 = 0x0005;
 442 constexpr chip::ClusterId kTemperatureMeasurementClusterId = 0x0402;
 443
 444 /*----------------------------------------------------------------------------*\
 445 | Cluster ApplicationBasic                                            | 0x050D |
 446 |------------------------------------------------------------------------------|
 447 | Commands:                                                           |        |
 448 |------------------------------------------------------------------------------|
 449 | Attributes:                                                         |        |
 450 | * VendorName                                                        | 0x0000 |
 451 | * VendorId                                                          | 0x0001 |
 452 | * ApplicationName                                                   | 0x0002 |
 453 | * ProductId                                                         | 0x0003 |
 454 | * ApplicationId                                                     | 0x0005 |
 455 | * CatalogVendorId                                                   | 0x0006 |
 456 | * ApplicationSatus                                                  | 0x0007 |
 457 | * ClusterRevision                                                   | 0xFFFD |
 458 \*----------------------------------------------------------------------------*/
 459
 460 /*
 461  * Discover Attributes
 462  */
 463 class DiscoverApplicationBasicAttributes : public ModelCommand
 464 {
 465 public:
 466     DiscoverApplicationBasicAttributes() : ModelCommand("discover") { ModelCommand::AddArguments(); }
 467
 468     ~DiscoverApplicationBasicAttributes()
 469     {
 470         delete onSuccessCallback;
 471         delete onFailureCallback;
 472     }
 473
 474     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
 475     {
 476         ChipLogProgress(chipTool, "Sending cluster (0x0000) command (0x0C) on endpoint %" PRIu16, endpointId);
 477
 478         chip::Controller::ApplicationBasicCluster cluster;
 479         cluster.Associate(device, endpointId);
 480         return cluster.DiscoverAttributes(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
 481     }
 482
 483 private:
 484     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
 485         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
 486     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
 487         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
 488 };
 489
 490 /*
 491  * Attribute VendorName
 492  */
 493 class ReadApplicationBasicVendorName : public ModelCommand
 494 {
 495 public:
 496     ReadApplicationBasicVendorName() : ModelCommand("read")
 497     {
 498         AddArgument("attr-name", "vendor-name");
 499         ModelCommand::AddArguments();
 500     }
 501
 502     ~ReadApplicationBasicVendorName()
 503     {
 504         delete onSuccessCallback;
 505         delete onFailureCallback;
 506     }
 507
 508     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
 509     {
 510         ChipLogProgress(chipTool, "Sending cluster (0x050D) command (0x00) on endpoint %" PRIu16, endpointId);
 511
 512         chip::Controller::ApplicationBasicCluster cluster;
 513         cluster.Associate(device, endpointId);
 514         return cluster.ReadAttributeVendorName(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
 515     }
 516
 517 private:
 518     chip::Callback::Callback<StringAttributeCallback> * onSuccessCallback =
 519         new chip::Callback::Callback<StringAttributeCallback>(OnStringAttributeResponse, this);
 520     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
 521         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
 522 };
 523
 524 /*
 525  * Attribute VendorId
 526  */
 527 class ReadApplicationBasicVendorId : public ModelCommand
 528 {
 529 public:
 530     ReadApplicationBasicVendorId() : ModelCommand("read")
 531     {
 532         AddArgument("attr-name", "vendor-id");
 533         ModelCommand::AddArguments();
 534     }
 535
 536     ~ReadApplicationBasicVendorId()
 537     {
 538         delete onSuccessCallback;
 539         delete onFailureCallback;
 540     }
 541
 542     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
 543     {
 544         ChipLogProgress(chipTool, "Sending cluster (0x050D) command (0x00) on endpoint %" PRIu16, endpointId);
 545
 546         chip::Controller::ApplicationBasicCluster cluster;
 547         cluster.Associate(device, endpointId);
 548         return cluster.ReadAttributeVendorId(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
 549     }
 550
 551 private:
 552     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
 553         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
 554     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
 555         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
 556 };
 557
 558 /*
 559  * Attribute ApplicationName
 560  */
 561 class ReadApplicationBasicApplicationName : public ModelCommand
 562 {
 563 public:
 564     ReadApplicationBasicApplicationName() : ModelCommand("read")
 565     {
 566         AddArgument("attr-name", "application-name");
 567         ModelCommand::AddArguments();
 568     }
 569
 570     ~ReadApplicationBasicApplicationName()
 571     {
 572         delete onSuccessCallback;
 573         delete onFailureCallback;
 574     }
 575
 576     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
 577     {
 578         ChipLogProgress(chipTool, "Sending cluster (0x050D) command (0x00) on endpoint %" PRIu16, endpointId);
 579
 580         chip::Controller::ApplicationBasicCluster cluster;
 581         cluster.Associate(device, endpointId);
 582         return cluster.ReadAttributeApplicationName(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
 583     }
 584
 585 private:
 586     chip::Callback::Callback<StringAttributeCallback> * onSuccessCallback =
 587         new chip::Callback::Callback<StringAttributeCallback>(OnStringAttributeResponse, this);
 588     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
 589         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
 590 };
 591
 592 /*
 593  * Attribute ProductId
 594  */
 595 class ReadApplicationBasicProductId : public ModelCommand
 596 {
 597 public:
 598     ReadApplicationBasicProductId() : ModelCommand("read")
 599     {
 600         AddArgument("attr-name", "product-id");
 601         ModelCommand::AddArguments();
 602     }
 603
 604     ~ReadApplicationBasicProductId()
 605     {
 606         delete onSuccessCallback;
 607         delete onFailureCallback;
 608     }
 609
 610     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
 611     {
 612         ChipLogProgress(chipTool, "Sending cluster (0x050D) command (0x00) on endpoint %" PRIu16, endpointId);
 613
 614         chip::Controller::ApplicationBasicCluster cluster;
 615         cluster.Associate(device, endpointId);
 616         return cluster.ReadAttributeProductId(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
 617     }
 618
 619 private:
 620     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
 621         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
 622     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
 623         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
 624 };
 625
 626 /*
 627  * Attribute ApplicationId
 628  */
 629 class ReadApplicationBasicApplicationId : public ModelCommand
 630 {
 631 public:
 632     ReadApplicationBasicApplicationId() : ModelCommand("read")
 633     {
 634         AddArgument("attr-name", "application-id");
 635         ModelCommand::AddArguments();
 636     }
 637
 638     ~ReadApplicationBasicApplicationId()
 639     {
 640         delete onSuccessCallback;
 641         delete onFailureCallback;
 642     }
 643
 644     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
 645     {
 646         ChipLogProgress(chipTool, "Sending cluster (0x050D) command (0x00) on endpoint %" PRIu16, endpointId);
 647
 648         chip::Controller::ApplicationBasicCluster cluster;
 649         cluster.Associate(device, endpointId);
 650         return cluster.ReadAttributeApplicationId(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
 651     }
 652
 653 private:
 654     chip::Callback::Callback<StringAttributeCallback> * onSuccessCallback =
 655         new chip::Callback::Callback<StringAttributeCallback>(OnStringAttributeResponse, this);
 656     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
 657         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
 658 };
 659
 660 /*
 661  * Attribute CatalogVendorId
 662  */
 663 class ReadApplicationBasicCatalogVendorId : public ModelCommand
 664 {
 665 public:
 666     ReadApplicationBasicCatalogVendorId() : ModelCommand("read")
 667     {
 668         AddArgument("attr-name", "catalog-vendor-id");
 669         ModelCommand::AddArguments();
 670     }
 671
 672     ~ReadApplicationBasicCatalogVendorId()
 673     {
 674         delete onSuccessCallback;
 675         delete onFailureCallback;
 676     }
 677
 678     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
 679     {
 680         ChipLogProgress(chipTool, "Sending cluster (0x050D) command (0x00) on endpoint %" PRIu16, endpointId);
 681
 682         chip::Controller::ApplicationBasicCluster cluster;
 683         cluster.Associate(device, endpointId);
 684         return cluster.ReadAttributeCatalogVendorId(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
 685     }
 686
 687 private:
 688     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
 689         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
 690     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
 691         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
 692 };
 693
 694 /*
 695  * Attribute ApplicationSatus
 696  */
 697 class ReadApplicationBasicApplicationSatus : public ModelCommand
 698 {
 699 public:
 700     ReadApplicationBasicApplicationSatus() : ModelCommand("read")
 701     {
 702         AddArgument("attr-name", "application-satus");
 703         ModelCommand::AddArguments();
 704     }
 705
 706     ~ReadApplicationBasicApplicationSatus()
 707     {
 708         delete onSuccessCallback;
 709         delete onFailureCallback;
 710     }
 711
 712     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
 713     {
 714         ChipLogProgress(chipTool, "Sending cluster (0x050D) command (0x00) on endpoint %" PRIu16, endpointId);
 715
 716         chip::Controller::ApplicationBasicCluster cluster;
 717         cluster.Associate(device, endpointId);
 718         return cluster.ReadAttributeApplicationSatus(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
 719     }
 720
 721 private:
 722     chip::Callback::Callback<Int8uAttributeCallback> * onSuccessCallback =
 723         new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
 724     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
 725         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
 726 };
 727
 728 /*
 729  * Attribute ClusterRevision
 730  */
 731 class ReadApplicationBasicClusterRevision : public ModelCommand
 732 {
 733 public:
 734     ReadApplicationBasicClusterRevision() : ModelCommand("read")
 735     {
 736         AddArgument("attr-name", "cluster-revision");
 737         ModelCommand::AddArguments();
 738     }
 739
 740     ~ReadApplicationBasicClusterRevision()
 741     {
 742         delete onSuccessCallback;
 743         delete onFailureCallback;
 744     }
 745
 746     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
 747     {
 748         ChipLogProgress(chipTool, "Sending cluster (0x050D) command (0x00) on endpoint %" PRIu16, endpointId);
 749
 750         chip::Controller::ApplicationBasicCluster cluster;
 751         cluster.Associate(device, endpointId);
 752         return cluster.ReadAttributeClusterRevision(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
 753     }
 754
 755 private:
 756     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
 757         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
 758     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
 759         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
 760 };
 761
 762 /*----------------------------------------------------------------------------*\
 763 | Cluster BarrierControl                                              | 0x0103 |
 764 |------------------------------------------------------------------------------|
 765 | Commands:                                                           |        |
 766 | * BarrierControlGoToPercent                                         |   0x00 |
 767 | * BarrierControlStop                                                |   0x01 |
 768 |------------------------------------------------------------------------------|
 769 | Attributes:                                                         |        |
 770 | * BarrierMovingState                                                | 0x0001 |
 771 | * BarrierSafetyStatus                                               | 0x0002 |
 772 | * BarrierCapabilities                                               | 0x0003 |
 773 | * BarrierPosition                                                   | 0x000A |
 774 | * ClusterRevision                                                   | 0xFFFD |
 775 \*----------------------------------------------------------------------------*/
 776
 777 /*
 778  * Command BarrierControlGoToPercent
 779  */
 780 class BarrierControlBarrierControlGoToPercent : public ModelCommand
 781 {
 782 public:
 783     BarrierControlBarrierControlGoToPercent() : ModelCommand("barrier-control-go-to-percent")
 784     {
 785         AddArgument("percentOpen", 0, UINT8_MAX, &mPercentOpen);
 786         ModelCommand::AddArguments();
 787     }
 788     ~BarrierControlBarrierControlGoToPercent()
 789     {
 790         delete onSuccessCallback;
 791         delete onFailureCallback;
 792     }
 793
 794     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
 795     {
 796         ChipLogProgress(chipTool, "Sending cluster (0x0103) command (0x00) on endpoint %" PRIu16, endpointId);
 797
 798         chip::Controller::BarrierControlCluster cluster;
 799         cluster.Associate(device, endpointId);
 800         return cluster.BarrierControlGoToPercent(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mPercentOpen);
 801     }
 802
 803 private:
 804     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
 805         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
 806     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
 807         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
 808     uint8_t mPercentOpen;
 809 };
 810
 811 /*
 812  * Command BarrierControlStop
 813  */
 814 class BarrierControlBarrierControlStop : public ModelCommand
 815 {
 816 public:
 817     BarrierControlBarrierControlStop() : ModelCommand("barrier-control-stop") { ModelCommand::AddArguments(); }
 818     ~BarrierControlBarrierControlStop()
 819     {
 820         delete onSuccessCallback;
 821         delete onFailureCallback;
 822     }
 823
 824     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
 825     {
 826         ChipLogProgress(chipTool, "Sending cluster (0x0103) command (0x01) on endpoint %" PRIu16, endpointId);
 827
 828         chip::Controller::BarrierControlCluster cluster;
 829         cluster.Associate(device, endpointId);
 830         return cluster.BarrierControlStop(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
 831     }
 832
 833 private:
 834     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
 835         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
 836     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
 837         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
 838 };
 839
 840 /*
 841  * Discover Attributes
 842  */
 843 class DiscoverBarrierControlAttributes : public ModelCommand
 844 {
 845 public:
 846     DiscoverBarrierControlAttributes() : ModelCommand("discover") { ModelCommand::AddArguments(); }
 847
 848     ~DiscoverBarrierControlAttributes()
 849     {
 850         delete onSuccessCallback;
 851         delete onFailureCallback;
 852     }
 853
 854     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
 855     {
 856         ChipLogProgress(chipTool, "Sending cluster (0x0000) command (0x0C) on endpoint %" PRIu16, endpointId);
 857
 858         chip::Controller::BarrierControlCluster cluster;
 859         cluster.Associate(device, endpointId);
 860         return cluster.DiscoverAttributes(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
 861     }
 862
 863 private:
 864     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
 865         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
 866     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
 867         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
 868 };
 869
 870 /*
 871  * Attribute BarrierMovingState
 872  */
 873 class ReadBarrierControlBarrierMovingState : public ModelCommand
 874 {
 875 public:
 876     ReadBarrierControlBarrierMovingState() : ModelCommand("read")
 877     {
 878         AddArgument("attr-name", "barrier-moving-state");
 879         ModelCommand::AddArguments();
 880     }
 881
 882     ~ReadBarrierControlBarrierMovingState()
 883     {
 884         delete onSuccessCallback;
 885         delete onFailureCallback;
 886     }
 887
 888     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
 889     {
 890         ChipLogProgress(chipTool, "Sending cluster (0x0103) command (0x00) on endpoint %" PRIu16, endpointId);
 891
 892         chip::Controller::BarrierControlCluster cluster;
 893         cluster.Associate(device, endpointId);
 894         return cluster.ReadAttributeBarrierMovingState(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
 895     }
 896
 897 private:
 898     chip::Callback::Callback<Int8uAttributeCallback> * onSuccessCallback =
 899         new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
 900     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
 901         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
 902 };
 903
 904 /*
 905  * Attribute BarrierSafetyStatus
 906  */
 907 class ReadBarrierControlBarrierSafetyStatus : public ModelCommand
 908 {
 909 public:
 910     ReadBarrierControlBarrierSafetyStatus() : ModelCommand("read")
 911     {
 912         AddArgument("attr-name", "barrier-safety-status");
 913         ModelCommand::AddArguments();
 914     }
 915
 916     ~ReadBarrierControlBarrierSafetyStatus()
 917     {
 918         delete onSuccessCallback;
 919         delete onFailureCallback;
 920     }
 921
 922     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
 923     {
 924         ChipLogProgress(chipTool, "Sending cluster (0x0103) command (0x00) on endpoint %" PRIu16, endpointId);
 925
 926         chip::Controller::BarrierControlCluster cluster;
 927         cluster.Associate(device, endpointId);
 928         return cluster.ReadAttributeBarrierSafetyStatus(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
 929     }
 930
 931 private:
 932     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
 933         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
 934     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
 935         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
 936 };
 937
 938 /*
 939  * Attribute BarrierCapabilities
 940  */
 941 class ReadBarrierControlBarrierCapabilities : public ModelCommand
 942 {
 943 public:
 944     ReadBarrierControlBarrierCapabilities() : ModelCommand("read")
 945     {
 946         AddArgument("attr-name", "barrier-capabilities");
 947         ModelCommand::AddArguments();
 948     }
 949
 950     ~ReadBarrierControlBarrierCapabilities()
 951     {
 952         delete onSuccessCallback;
 953         delete onFailureCallback;
 954     }
 955
 956     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
 957     {
 958         ChipLogProgress(chipTool, "Sending cluster (0x0103) command (0x00) on endpoint %" PRIu16, endpointId);
 959
 960         chip::Controller::BarrierControlCluster cluster;
 961         cluster.Associate(device, endpointId);
 962         return cluster.ReadAttributeBarrierCapabilities(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
 963     }
 964
 965 private:
 966     chip::Callback::Callback<Int8uAttributeCallback> * onSuccessCallback =
 967         new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
 968     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
 969         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
 970 };
 971
 972 /*
 973  * Attribute BarrierPosition
 974  */
 975 class ReadBarrierControlBarrierPosition : public ModelCommand
 976 {
 977 public:
 978     ReadBarrierControlBarrierPosition() : ModelCommand("read")
 979     {
 980         AddArgument("attr-name", "barrier-position");
 981         ModelCommand::AddArguments();
 982     }
 983
 984     ~ReadBarrierControlBarrierPosition()
 985     {
 986         delete onSuccessCallback;
 987         delete onFailureCallback;
 988     }
 989
 990     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
 991     {
 992         ChipLogProgress(chipTool, "Sending cluster (0x0103) command (0x00) on endpoint %" PRIu16, endpointId);
 993
 994         chip::Controller::BarrierControlCluster cluster;
 995         cluster.Associate(device, endpointId);
 996         return cluster.ReadAttributeBarrierPosition(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
 997     }
 998
 999 private:
1000     chip::Callback::Callback<Int8uAttributeCallback> * onSuccessCallback =
1001         new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
1002     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
1003         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
1004 };
1005
1006 /*
1007  * Attribute ClusterRevision
1008  */
1009 class ReadBarrierControlClusterRevision : public ModelCommand
1010 {
1011 public:
1012     ReadBarrierControlClusterRevision() : ModelCommand("read")
1013     {
1014         AddArgument("attr-name", "cluster-revision");
1015         ModelCommand::AddArguments();
1016     }
1017
1018     ~ReadBarrierControlClusterRevision()
1019     {
1020         delete onSuccessCallback;
1021         delete onFailureCallback;
1022     }
1023
1024     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
1025     {
1026         ChipLogProgress(chipTool, "Sending cluster (0x0103) command (0x00) on endpoint %" PRIu16, endpointId);
1027
1028         chip::Controller::BarrierControlCluster cluster;
1029         cluster.Associate(device, endpointId);
1030         return cluster.ReadAttributeClusterRevision(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
1031     }
1032
1033 private:
1034     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
1035         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
1036     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
1037         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
1038 };
1039
1040 /*----------------------------------------------------------------------------*\
1041 | Cluster Basic                                                       | 0x0028 |
1042 |------------------------------------------------------------------------------|
1043 | Commands:                                                           |        |
1044 | * MfgSpecificPing                                                   |   0x00 |
1045 |------------------------------------------------------------------------------|
1046 | Attributes:                                                         |        |
1047 | * InteractionModelVersion                                           | 0x0000 |
1048 | * VendorName                                                        | 0x0001 |
1049 | * VendorID                                                          | 0x0002 |
1050 | * ProductName                                                       | 0x0003 |
1051 | * ProductID                                                         | 0x0004 |
1052 | * UserLabel                                                         | 0x0005 |
1053 | * Location                                                          | 0x0006 |
1054 | * HardwareVersion                                                   | 0x0007 |
1055 | * HardwareVersionString                                             | 0x0008 |
1056 | * SoftwareVersion                                                   | 0x0009 |
1057 | * SoftwareVersionString                                             | 0x000A |
1058 | * ClusterRevision                                                   | 0xFFFD |
1059 \*----------------------------------------------------------------------------*/
1060
1061 /*
1062  * Command MfgSpecificPing
1063  */
1064 class BasicMfgSpecificPing : public ModelCommand
1065 {
1066 public:
1067     BasicMfgSpecificPing() : ModelCommand("mfg-specific-ping") { ModelCommand::AddArguments(); }
1068     ~BasicMfgSpecificPing()
1069     {
1070         delete onSuccessCallback;
1071         delete onFailureCallback;
1072     }
1073
1074     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
1075     {
1076         ChipLogProgress(chipTool, "Sending cluster (0x0028) command (0x00) on endpoint %" PRIu16, endpointId);
1077
1078         chip::Controller::BasicCluster cluster;
1079         cluster.Associate(device, endpointId);
1080         return cluster.MfgSpecificPing(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
1081     }
1082
1083 private:
1084     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
1085         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
1086     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
1087         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
1088 };
1089
1090 /*
1091  * Discover Attributes
1092  */
1093 class DiscoverBasicAttributes : public ModelCommand
1094 {
1095 public:
1096     DiscoverBasicAttributes() : ModelCommand("discover") { ModelCommand::AddArguments(); }
1097
1098     ~DiscoverBasicAttributes()
1099     {
1100         delete onSuccessCallback;
1101         delete onFailureCallback;
1102     }
1103
1104     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
1105     {
1106         ChipLogProgress(chipTool, "Sending cluster (0x0000) command (0x0C) on endpoint %" PRIu16, endpointId);
1107
1108         chip::Controller::BasicCluster cluster;
1109         cluster.Associate(device, endpointId);
1110         return cluster.DiscoverAttributes(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
1111     }
1112
1113 private:
1114     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
1115         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
1116     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
1117         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
1118 };
1119
1120 /*
1121  * Attribute InteractionModelVersion
1122  */
1123 class ReadBasicInteractionModelVersion : public ModelCommand
1124 {
1125 public:
1126     ReadBasicInteractionModelVersion() : ModelCommand("read")
1127     {
1128         AddArgument("attr-name", "interaction-model-version");
1129         ModelCommand::AddArguments();
1130     }
1131
1132     ~ReadBasicInteractionModelVersion()
1133     {
1134         delete onSuccessCallback;
1135         delete onFailureCallback;
1136     }
1137
1138     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
1139     {
1140         ChipLogProgress(chipTool, "Sending cluster (0x0028) command (0x00) on endpoint %" PRIu16, endpointId);
1141
1142         chip::Controller::BasicCluster cluster;
1143         cluster.Associate(device, endpointId);
1144         return cluster.ReadAttributeInteractionModelVersion(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
1145     }
1146
1147 private:
1148     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
1149         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
1150     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
1151         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
1152 };
1153
1154 /*
1155  * Attribute VendorName
1156  */
1157 class ReadBasicVendorName : public ModelCommand
1158 {
1159 public:
1160     ReadBasicVendorName() : ModelCommand("read")
1161     {
1162         AddArgument("attr-name", "vendor-name");
1163         ModelCommand::AddArguments();
1164     }
1165
1166     ~ReadBasicVendorName()
1167     {
1168         delete onSuccessCallback;
1169         delete onFailureCallback;
1170     }
1171
1172     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
1173     {
1174         ChipLogProgress(chipTool, "Sending cluster (0x0028) command (0x00) on endpoint %" PRIu16, endpointId);
1175
1176         chip::Controller::BasicCluster cluster;
1177         cluster.Associate(device, endpointId);
1178         return cluster.ReadAttributeVendorName(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
1179     }
1180
1181 private:
1182     chip::Callback::Callback<StringAttributeCallback> * onSuccessCallback =
1183         new chip::Callback::Callback<StringAttributeCallback>(OnStringAttributeResponse, this);
1184     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
1185         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
1186 };
1187
1188 /*
1189  * Attribute VendorID
1190  */
1191 class ReadBasicVendorID : public ModelCommand
1192 {
1193 public:
1194     ReadBasicVendorID() : ModelCommand("read")
1195     {
1196         AddArgument("attr-name", "vendor-id");
1197         ModelCommand::AddArguments();
1198     }
1199
1200     ~ReadBasicVendorID()
1201     {
1202         delete onSuccessCallback;
1203         delete onFailureCallback;
1204     }
1205
1206     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
1207     {
1208         ChipLogProgress(chipTool, "Sending cluster (0x0028) command (0x00) on endpoint %" PRIu16, endpointId);
1209
1210         chip::Controller::BasicCluster cluster;
1211         cluster.Associate(device, endpointId);
1212         return cluster.ReadAttributeVendorID(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
1213     }
1214
1215 private:
1216     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
1217         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
1218     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
1219         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
1220 };
1221
1222 /*
1223  * Attribute ProductName
1224  */
1225 class ReadBasicProductName : public ModelCommand
1226 {
1227 public:
1228     ReadBasicProductName() : ModelCommand("read")
1229     {
1230         AddArgument("attr-name", "product-name");
1231         ModelCommand::AddArguments();
1232     }
1233
1234     ~ReadBasicProductName()
1235     {
1236         delete onSuccessCallback;
1237         delete onFailureCallback;
1238     }
1239
1240     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
1241     {
1242         ChipLogProgress(chipTool, "Sending cluster (0x0028) command (0x00) on endpoint %" PRIu16, endpointId);
1243
1244         chip::Controller::BasicCluster cluster;
1245         cluster.Associate(device, endpointId);
1246         return cluster.ReadAttributeProductName(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
1247     }
1248
1249 private:
1250     chip::Callback::Callback<StringAttributeCallback> * onSuccessCallback =
1251         new chip::Callback::Callback<StringAttributeCallback>(OnStringAttributeResponse, this);
1252     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
1253         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
1254 };
1255
1256 /*
1257  * Attribute ProductID
1258  */
1259 class ReadBasicProductID : public ModelCommand
1260 {
1261 public:
1262     ReadBasicProductID() : ModelCommand("read")
1263     {
1264         AddArgument("attr-name", "product-id");
1265         ModelCommand::AddArguments();
1266     }
1267
1268     ~ReadBasicProductID()
1269     {
1270         delete onSuccessCallback;
1271         delete onFailureCallback;
1272     }
1273
1274     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
1275     {
1276         ChipLogProgress(chipTool, "Sending cluster (0x0028) command (0x00) on endpoint %" PRIu16, endpointId);
1277
1278         chip::Controller::BasicCluster cluster;
1279         cluster.Associate(device, endpointId);
1280         return cluster.ReadAttributeProductID(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
1281     }
1282
1283 private:
1284     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
1285         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
1286     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
1287         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
1288 };
1289
1290 /*
1291  * Attribute UserLabel
1292  */
1293 class ReadBasicUserLabel : public ModelCommand
1294 {
1295 public:
1296     ReadBasicUserLabel() : ModelCommand("read")
1297     {
1298         AddArgument("attr-name", "user-label");
1299         ModelCommand::AddArguments();
1300     }
1301
1302     ~ReadBasicUserLabel()
1303     {
1304         delete onSuccessCallback;
1305         delete onFailureCallback;
1306     }
1307
1308     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
1309     {
1310         ChipLogProgress(chipTool, "Sending cluster (0x0028) command (0x00) on endpoint %" PRIu16, endpointId);
1311
1312         chip::Controller::BasicCluster cluster;
1313         cluster.Associate(device, endpointId);
1314         return cluster.ReadAttributeUserLabel(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
1315     }
1316
1317 private:
1318     chip::Callback::Callback<StringAttributeCallback> * onSuccessCallback =
1319         new chip::Callback::Callback<StringAttributeCallback>(OnStringAttributeResponse, this);
1320     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
1321         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
1322 };
1323
1324 class WriteBasicUserLabel : public ModelCommand
1325 {
1326 public:
1327     WriteBasicUserLabel() : ModelCommand("write")
1328     {
1329         AddArgument("attr-name", "user-label");
1330         AddArgument("attr-value", &mValue);
1331         ModelCommand::AddArguments();
1332     }
1333
1334     ~WriteBasicUserLabel()
1335     {
1336         delete onSuccessCallback;
1337         delete onFailureCallback;
1338     }
1339
1340     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
1341     {
1342         ChipLogProgress(chipTool, "Sending cluster (0x0028) command (0x01) on endpoint %" PRIu16, endpointId);
1343
1344         chip::Controller::BasicCluster cluster;
1345         cluster.Associate(device, endpointId);
1346         return cluster.WriteAttributeUserLabel(onSuccessCallback->Cancel(), onFailureCallback->Cancel(),
1347                                                chip::ByteSpan(chip::Uint8::from_char(mValue), strlen(mValue)));
1348     }
1349
1350 private:
1351     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
1352         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
1353     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
1354         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
1355     char * mValue;
1356 };
1357
1358 /*
1359  * Attribute Location
1360  */
1361 class ReadBasicLocation : public ModelCommand
1362 {
1363 public:
1364     ReadBasicLocation() : ModelCommand("read")
1365     {
1366         AddArgument("attr-name", "location");
1367         ModelCommand::AddArguments();
1368     }
1369
1370     ~ReadBasicLocation()
1371     {
1372         delete onSuccessCallback;
1373         delete onFailureCallback;
1374     }
1375
1376     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
1377     {
1378         ChipLogProgress(chipTool, "Sending cluster (0x0028) command (0x00) on endpoint %" PRIu16, endpointId);
1379
1380         chip::Controller::BasicCluster cluster;
1381         cluster.Associate(device, endpointId);
1382         return cluster.ReadAttributeLocation(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
1383     }
1384
1385 private:
1386     chip::Callback::Callback<StringAttributeCallback> * onSuccessCallback =
1387         new chip::Callback::Callback<StringAttributeCallback>(OnStringAttributeResponse, this);
1388     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
1389         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
1390 };
1391
1392 class WriteBasicLocation : public ModelCommand
1393 {
1394 public:
1395     WriteBasicLocation() : ModelCommand("write")
1396     {
1397         AddArgument("attr-name", "location");
1398         AddArgument("attr-value", &mValue);
1399         ModelCommand::AddArguments();
1400     }
1401
1402     ~WriteBasicLocation()
1403     {
1404         delete onSuccessCallback;
1405         delete onFailureCallback;
1406     }
1407
1408     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
1409     {
1410         ChipLogProgress(chipTool, "Sending cluster (0x0028) command (0x01) on endpoint %" PRIu16, endpointId);
1411
1412         chip::Controller::BasicCluster cluster;
1413         cluster.Associate(device, endpointId);
1414         return cluster.WriteAttributeLocation(onSuccessCallback->Cancel(), onFailureCallback->Cancel(),
1415                                               chip::ByteSpan(chip::Uint8::from_char(mValue), strlen(mValue)));
1416     }
1417
1418 private:
1419     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
1420         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
1421     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
1422         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
1423     char * mValue;
1424 };
1425
1426 /*
1427  * Attribute HardwareVersion
1428  */
1429 class ReadBasicHardwareVersion : public ModelCommand
1430 {
1431 public:
1432     ReadBasicHardwareVersion() : ModelCommand("read")
1433     {
1434         AddArgument("attr-name", "hardware-version");
1435         ModelCommand::AddArguments();
1436     }
1437
1438     ~ReadBasicHardwareVersion()
1439     {
1440         delete onSuccessCallback;
1441         delete onFailureCallback;
1442     }
1443
1444     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
1445     {
1446         ChipLogProgress(chipTool, "Sending cluster (0x0028) command (0x00) on endpoint %" PRIu16, endpointId);
1447
1448         chip::Controller::BasicCluster cluster;
1449         cluster.Associate(device, endpointId);
1450         return cluster.ReadAttributeHardwareVersion(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
1451     }
1452
1453 private:
1454     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
1455         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
1456     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
1457         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
1458 };
1459
1460 /*
1461  * Attribute HardwareVersionString
1462  */
1463 class ReadBasicHardwareVersionString : public ModelCommand
1464 {
1465 public:
1466     ReadBasicHardwareVersionString() : ModelCommand("read")
1467     {
1468         AddArgument("attr-name", "hardware-version-string");
1469         ModelCommand::AddArguments();
1470     }
1471
1472     ~ReadBasicHardwareVersionString()
1473     {
1474         delete onSuccessCallback;
1475         delete onFailureCallback;
1476     }
1477
1478     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
1479     {
1480         ChipLogProgress(chipTool, "Sending cluster (0x0028) command (0x00) on endpoint %" PRIu16, endpointId);
1481
1482         chip::Controller::BasicCluster cluster;
1483         cluster.Associate(device, endpointId);
1484         return cluster.ReadAttributeHardwareVersionString(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
1485     }
1486
1487 private:
1488     chip::Callback::Callback<StringAttributeCallback> * onSuccessCallback =
1489         new chip::Callback::Callback<StringAttributeCallback>(OnStringAttributeResponse, this);
1490     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
1491         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
1492 };
1493
1494 /*
1495  * Attribute SoftwareVersion
1496  */
1497 class ReadBasicSoftwareVersion : public ModelCommand
1498 {
1499 public:
1500     ReadBasicSoftwareVersion() : ModelCommand("read")
1501     {
1502         AddArgument("attr-name", "software-version");
1503         ModelCommand::AddArguments();
1504     }
1505
1506     ~ReadBasicSoftwareVersion()
1507     {
1508         delete onSuccessCallback;
1509         delete onFailureCallback;
1510     }
1511
1512     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
1513     {
1514         ChipLogProgress(chipTool, "Sending cluster (0x0028) command (0x00) on endpoint %" PRIu16, endpointId);
1515
1516         chip::Controller::BasicCluster cluster;
1517         cluster.Associate(device, endpointId);
1518         return cluster.ReadAttributeSoftwareVersion(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
1519     }
1520
1521 private:
1522     chip::Callback::Callback<Int32uAttributeCallback> * onSuccessCallback =
1523         new chip::Callback::Callback<Int32uAttributeCallback>(OnInt32uAttributeResponse, this);
1524     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
1525         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
1526 };
1527
1528 /*
1529  * Attribute SoftwareVersionString
1530  */
1531 class ReadBasicSoftwareVersionString : public ModelCommand
1532 {
1533 public:
1534     ReadBasicSoftwareVersionString() : ModelCommand("read")
1535     {
1536         AddArgument("attr-name", "software-version-string");
1537         ModelCommand::AddArguments();
1538     }
1539
1540     ~ReadBasicSoftwareVersionString()
1541     {
1542         delete onSuccessCallback;
1543         delete onFailureCallback;
1544     }
1545
1546     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
1547     {
1548         ChipLogProgress(chipTool, "Sending cluster (0x0028) command (0x00) on endpoint %" PRIu16, endpointId);
1549
1550         chip::Controller::BasicCluster cluster;
1551         cluster.Associate(device, endpointId);
1552         return cluster.ReadAttributeSoftwareVersionString(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
1553     }
1554
1555 private:
1556     chip::Callback::Callback<StringAttributeCallback> * onSuccessCallback =
1557         new chip::Callback::Callback<StringAttributeCallback>(OnStringAttributeResponse, this);
1558     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
1559         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
1560 };
1561
1562 /*
1563  * Attribute ClusterRevision
1564  */
1565 class ReadBasicClusterRevision : public ModelCommand
1566 {
1567 public:
1568     ReadBasicClusterRevision() : ModelCommand("read")
1569     {
1570         AddArgument("attr-name", "cluster-revision");
1571         ModelCommand::AddArguments();
1572     }
1573
1574     ~ReadBasicClusterRevision()
1575     {
1576         delete onSuccessCallback;
1577         delete onFailureCallback;
1578     }
1579
1580     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
1581     {
1582         ChipLogProgress(chipTool, "Sending cluster (0x0028) command (0x00) on endpoint %" PRIu16, endpointId);
1583
1584         chip::Controller::BasicCluster cluster;
1585         cluster.Associate(device, endpointId);
1586         return cluster.ReadAttributeClusterRevision(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
1587     }
1588
1589 private:
1590     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
1591         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
1592     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
1593         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
1594 };
1595
1596 /*----------------------------------------------------------------------------*\
1597 | Cluster Binding                                                     | 0xF000 |
1598 |------------------------------------------------------------------------------|
1599 | Commands:                                                           |        |
1600 | * Bind                                                              |   0x00 |
1601 | * Unbind                                                            |   0x01 |
1602 |------------------------------------------------------------------------------|
1603 | Attributes:                                                         |        |
1604 | * ClusterRevision                                                   | 0xFFFD |
1605 \*----------------------------------------------------------------------------*/
1606
1607 /*
1608  * Command Bind
1609  */
1610 class BindingBind : public ModelCommand
1611 {
1612 public:
1613     BindingBind() : ModelCommand("bind")
1614     {
1615         AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
1616         AddArgument("groupId", 0, UINT16_MAX, &mGroupId);
1617         AddArgument("endpointId", 0, UINT8_MAX, &mEndpointId);
1618         AddArgument("clusterId", 0, UINT16_MAX, &mClusterId);
1619         ModelCommand::AddArguments();
1620     }
1621     ~BindingBind()
1622     {
1623         delete onSuccessCallback;
1624         delete onFailureCallback;
1625     }
1626
1627     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
1628     {
1629         ChipLogProgress(chipTool, "Sending cluster (0xF000) command (0x00) on endpoint %" PRIu16, endpointId);
1630
1631         chip::Controller::BindingCluster cluster;
1632         cluster.Associate(device, endpointId);
1633         return cluster.Bind(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mNodeId, mGroupId, mEndpointId, mClusterId);
1634     }
1635
1636 private:
1637     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
1638         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
1639     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
1640         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
1641     chip::NodeId mNodeId;
1642     chip::GroupId mGroupId;
1643     chip::EndpointId mEndpointId;
1644     chip::ClusterId mClusterId;
1645 };
1646
1647 /*
1648  * Command Unbind
1649  */
1650 class BindingUnbind : public ModelCommand
1651 {
1652 public:
1653     BindingUnbind() : ModelCommand("unbind")
1654     {
1655         AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
1656         AddArgument("groupId", 0, UINT16_MAX, &mGroupId);
1657         AddArgument("endpointId", 0, UINT8_MAX, &mEndpointId);
1658         AddArgument("clusterId", 0, UINT16_MAX, &mClusterId);
1659         ModelCommand::AddArguments();
1660     }
1661     ~BindingUnbind()
1662     {
1663         delete onSuccessCallback;
1664         delete onFailureCallback;
1665     }
1666
1667     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
1668     {
1669         ChipLogProgress(chipTool, "Sending cluster (0xF000) command (0x01) on endpoint %" PRIu16, endpointId);
1670
1671         chip::Controller::BindingCluster cluster;
1672         cluster.Associate(device, endpointId);
1673         return cluster.Unbind(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mNodeId, mGroupId, mEndpointId, mClusterId);
1674     }
1675
1676 private:
1677     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
1678         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
1679     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
1680         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
1681     chip::NodeId mNodeId;
1682     chip::GroupId mGroupId;
1683     chip::EndpointId mEndpointId;
1684     chip::ClusterId mClusterId;
1685 };
1686
1687 /*
1688  * Discover Attributes
1689  */
1690 class DiscoverBindingAttributes : public ModelCommand
1691 {
1692 public:
1693     DiscoverBindingAttributes() : ModelCommand("discover") { ModelCommand::AddArguments(); }
1694
1695     ~DiscoverBindingAttributes()
1696     {
1697         delete onSuccessCallback;
1698         delete onFailureCallback;
1699     }
1700
1701     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
1702     {
1703         ChipLogProgress(chipTool, "Sending cluster (0x0000) command (0x0C) on endpoint %" PRIu16, endpointId);
1704
1705         chip::Controller::BindingCluster cluster;
1706         cluster.Associate(device, endpointId);
1707         return cluster.DiscoverAttributes(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
1708     }
1709
1710 private:
1711     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
1712         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
1713     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
1714         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
1715 };
1716
1717 /*
1718  * Attribute ClusterRevision
1719  */
1720 class ReadBindingClusterRevision : public ModelCommand
1721 {
1722 public:
1723     ReadBindingClusterRevision() : ModelCommand("read")
1724     {
1725         AddArgument("attr-name", "cluster-revision");
1726         ModelCommand::AddArguments();
1727     }
1728
1729     ~ReadBindingClusterRevision()
1730     {
1731         delete onSuccessCallback;
1732         delete onFailureCallback;
1733     }
1734
1735     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
1736     {
1737         ChipLogProgress(chipTool, "Sending cluster (0xF000) command (0x00) on endpoint %" PRIu16, endpointId);
1738
1739         chip::Controller::BindingCluster cluster;
1740         cluster.Associate(device, endpointId);
1741         return cluster.ReadAttributeClusterRevision(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
1742     }
1743
1744 private:
1745     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
1746         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
1747     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
1748         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
1749 };
1750
1751 /*----------------------------------------------------------------------------*\
1752 | Cluster ColorControl                                                | 0x0300 |
1753 |------------------------------------------------------------------------------|
1754 | Commands:                                                           |        |
1755 | * MoveColor                                                         |   0x08 |
1756 | * MoveColorTemperature                                              |   0x4B |
1757 | * MoveHue                                                           |   0x01 |
1758 | * MoveSaturation                                                    |   0x04 |
1759 | * MoveToColor                                                       |   0x07 |
1760 | * MoveToColorTemperature                                            |   0x0A |
1761 | * MoveToHue                                                         |   0x00 |
1762 | * MoveToHueAndSaturation                                            |   0x06 |
1763 | * MoveToSaturation                                                  |   0x03 |
1764 | * StepColor                                                         |   0x09 |
1765 | * StepColorTemperature                                              |   0x4C |
1766 | * StepHue                                                           |   0x02 |
1767 | * StepSaturation                                                    |   0x05 |
1768 | * StopMoveStep                                                      |   0x47 |
1769 |------------------------------------------------------------------------------|
1770 | Attributes:                                                         |        |
1771 | * CurrentHue                                                        | 0x0000 |
1772 | * CurrentSaturation                                                 | 0x0001 |
1773 | * RemainingTime                                                     | 0x0002 |
1774 | * CurrentX                                                          | 0x0003 |
1775 | * CurrentY                                                          | 0x0004 |
1776 | * DriftCompensation                                                 | 0x0005 |
1777 | * CompensationText                                                  | 0x0006 |
1778 | * ColorTemperature                                                  | 0x0007 |
1779 | * ColorMode                                                         | 0x0008 |
1780 | * ColorControlOptions                                               | 0x000F |
1781 | * NumberOfPrimaries                                                 | 0x0010 |
1782 | * Primary1X                                                         | 0x0011 |
1783 | * Primary1Y                                                         | 0x0012 |
1784 | * Primary1Intensity                                                 | 0x0013 |
1785 | * Primary2X                                                         | 0x0015 |
1786 | * Primary2Y                                                         | 0x0016 |
1787 | * Primary2Intensity                                                 | 0x0017 |
1788 | * Primary3X                                                         | 0x0019 |
1789 | * Primary3Y                                                         | 0x001A |
1790 | * Primary3Intensity                                                 | 0x001B |
1791 | * Primary4X                                                         | 0x0020 |
1792 | * Primary4Y                                                         | 0x0021 |
1793 | * Primary4Intensity                                                 | 0x0022 |
1794 | * Primary5X                                                         | 0x0024 |
1795 | * Primary5Y                                                         | 0x0025 |
1796 | * Primary5Intensity                                                 | 0x0026 |
1797 | * Primary6X                                                         | 0x0028 |
1798 | * Primary6Y                                                         | 0x0029 |
1799 | * Primary6Intensity                                                 | 0x002A |
1800 | * WhitePointX                                                       | 0x0030 |
1801 | * WhitePointY                                                       | 0x0031 |
1802 | * ColorPointRX                                                      | 0x0032 |
1803 | * ColorPointRY                                                      | 0x0033 |
1804 | * ColorPointRIntensity                                              | 0x0034 |
1805 | * ColorPointGX                                                      | 0x0036 |
1806 | * ColorPointGY                                                      | 0x0037 |
1807 | * ColorPointGIntensity                                              | 0x0038 |
1808 | * ColorPointBX                                                      | 0x003A |
1809 | * ColorPointBY                                                      | 0x003B |
1810 | * ColorPointBIntensity                                              | 0x003C |
1811 | * EnhancedCurrentHue                                                | 0x4000 |
1812 | * EnhancedColorMode                                                 | 0x4001 |
1813 | * ColorLoopActive                                                   | 0x4002 |
1814 | * ColorLoopDirection                                                | 0x4003 |
1815 | * ColorLoopTime                                                     | 0x4004 |
1816 | * ColorCapabilities                                                 | 0x400A |
1817 | * ColorTempPhysicalMin                                              | 0x400B |
1818 | * ColorTempPhysicalMax                                              | 0x400C |
1819 | * CoupleColorTempToLevelMinMireds                                   | 0x400D |
1820 | * StartUpColorTemperatureMireds                                     | 0x4010 |
1821 | * ClusterRevision                                                   | 0xFFFD |
1822 \*----------------------------------------------------------------------------*/
1823
1824 /*
1825  * Command MoveColor
1826  */
1827 class ColorControlMoveColor : public ModelCommand
1828 {
1829 public:
1830     ColorControlMoveColor() : ModelCommand("move-color")
1831     {
1832         AddArgument("rateX", INT16_MIN, INT16_MAX, &mRateX);
1833         AddArgument("rateY", INT16_MIN, INT16_MAX, &mRateY);
1834         AddArgument("optionsMask", 0, UINT8_MAX, &mOptionsMask);
1835         AddArgument("optionsOverride", 0, UINT8_MAX, &mOptionsOverride);
1836         ModelCommand::AddArguments();
1837     }
1838     ~ColorControlMoveColor()
1839     {
1840         delete onSuccessCallback;
1841         delete onFailureCallback;
1842     }
1843
1844     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
1845     {
1846         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x08) on endpoint %" PRIu16, endpointId);
1847
1848         chip::Controller::ColorControlCluster cluster;
1849         cluster.Associate(device, endpointId);
1850         return cluster.MoveColor(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mRateX, mRateY, mOptionsMask,
1851                                  mOptionsOverride);
1852     }
1853
1854 private:
1855     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
1856         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
1857     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
1858         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
1859     int16_t mRateX;
1860     int16_t mRateY;
1861     uint8_t mOptionsMask;
1862     uint8_t mOptionsOverride;
1863 };
1864
1865 /*
1866  * Command MoveColorTemperature
1867  */
1868 class ColorControlMoveColorTemperature : public ModelCommand
1869 {
1870 public:
1871     ColorControlMoveColorTemperature() : ModelCommand("move-color-temperature")
1872     {
1873         AddArgument("moveMode", 0, UINT8_MAX, &mMoveMode);
1874         AddArgument("rate", 0, UINT16_MAX, &mRate);
1875         AddArgument("colorTemperatureMinimum", 0, UINT16_MAX, &mColorTemperatureMinimum);
1876         AddArgument("colorTemperatureMaximum", 0, UINT16_MAX, &mColorTemperatureMaximum);
1877         AddArgument("optionsMask", 0, UINT8_MAX, &mOptionsMask);
1878         AddArgument("optionsOverride", 0, UINT8_MAX, &mOptionsOverride);
1879         ModelCommand::AddArguments();
1880     }
1881     ~ColorControlMoveColorTemperature()
1882     {
1883         delete onSuccessCallback;
1884         delete onFailureCallback;
1885     }
1886
1887     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
1888     {
1889         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x4B) on endpoint %" PRIu16, endpointId);
1890
1891         chip::Controller::ColorControlCluster cluster;
1892         cluster.Associate(device, endpointId);
1893         return cluster.MoveColorTemperature(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMoveMode, mRate,
1894                                             mColorTemperatureMinimum, mColorTemperatureMaximum, mOptionsMask, mOptionsOverride);
1895     }
1896
1897 private:
1898     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
1899         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
1900     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
1901         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
1902     uint8_t mMoveMode;
1903     uint16_t mRate;
1904     uint16_t mColorTemperatureMinimum;
1905     uint16_t mColorTemperatureMaximum;
1906     uint8_t mOptionsMask;
1907     uint8_t mOptionsOverride;
1908 };
1909
1910 /*
1911  * Command MoveHue
1912  */
1913 class ColorControlMoveHue : public ModelCommand
1914 {
1915 public:
1916     ColorControlMoveHue() : ModelCommand("move-hue")
1917     {
1918         AddArgument("moveMode", 0, UINT8_MAX, &mMoveMode);
1919         AddArgument("rate", 0, UINT8_MAX, &mRate);
1920         AddArgument("optionsMask", 0, UINT8_MAX, &mOptionsMask);
1921         AddArgument("optionsOverride", 0, UINT8_MAX, &mOptionsOverride);
1922         ModelCommand::AddArguments();
1923     }
1924     ~ColorControlMoveHue()
1925     {
1926         delete onSuccessCallback;
1927         delete onFailureCallback;
1928     }
1929
1930     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
1931     {
1932         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x01) on endpoint %" PRIu16, endpointId);
1933
1934         chip::Controller::ColorControlCluster cluster;
1935         cluster.Associate(device, endpointId);
1936         return cluster.MoveHue(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMoveMode, mRate, mOptionsMask,
1937                                mOptionsOverride);
1938     }
1939
1940 private:
1941     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
1942         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
1943     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
1944         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
1945     uint8_t mMoveMode;
1946     uint8_t mRate;
1947     uint8_t mOptionsMask;
1948     uint8_t mOptionsOverride;
1949 };
1950
1951 /*
1952  * Command MoveSaturation
1953  */
1954 class ColorControlMoveSaturation : public ModelCommand
1955 {
1956 public:
1957     ColorControlMoveSaturation() : ModelCommand("move-saturation")
1958     {
1959         AddArgument("moveMode", 0, UINT8_MAX, &mMoveMode);
1960         AddArgument("rate", 0, UINT8_MAX, &mRate);
1961         AddArgument("optionsMask", 0, UINT8_MAX, &mOptionsMask);
1962         AddArgument("optionsOverride", 0, UINT8_MAX, &mOptionsOverride);
1963         ModelCommand::AddArguments();
1964     }
1965     ~ColorControlMoveSaturation()
1966     {
1967         delete onSuccessCallback;
1968         delete onFailureCallback;
1969     }
1970
1971     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
1972     {
1973         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x04) on endpoint %" PRIu16, endpointId);
1974
1975         chip::Controller::ColorControlCluster cluster;
1976         cluster.Associate(device, endpointId);
1977         return cluster.MoveSaturation(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMoveMode, mRate, mOptionsMask,
1978                                       mOptionsOverride);
1979     }
1980
1981 private:
1982     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
1983         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
1984     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
1985         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
1986     uint8_t mMoveMode;
1987     uint8_t mRate;
1988     uint8_t mOptionsMask;
1989     uint8_t mOptionsOverride;
1990 };
1991
1992 /*
1993  * Command MoveToColor
1994  */
1995 class ColorControlMoveToColor : public ModelCommand
1996 {
1997 public:
1998     ColorControlMoveToColor() : ModelCommand("move-to-color")
1999     {
2000         AddArgument("colorX", 0, UINT16_MAX, &mColorX);
2001         AddArgument("colorY", 0, UINT16_MAX, &mColorY);
2002         AddArgument("transitionTime", 0, UINT16_MAX, &mTransitionTime);
2003         AddArgument("optionsMask", 0, UINT8_MAX, &mOptionsMask);
2004         AddArgument("optionsOverride", 0, UINT8_MAX, &mOptionsOverride);
2005         ModelCommand::AddArguments();
2006     }
2007     ~ColorControlMoveToColor()
2008     {
2009         delete onSuccessCallback;
2010         delete onFailureCallback;
2011     }
2012
2013     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
2014     {
2015         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x07) on endpoint %" PRIu16, endpointId);
2016
2017         chip::Controller::ColorControlCluster cluster;
2018         cluster.Associate(device, endpointId);
2019         return cluster.MoveToColor(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mColorX, mColorY, mTransitionTime,
2020                                    mOptionsMask, mOptionsOverride);
2021     }
2022
2023 private:
2024     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
2025         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
2026     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
2027         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
2028     uint16_t mColorX;
2029     uint16_t mColorY;
2030     uint16_t mTransitionTime;
2031     uint8_t mOptionsMask;
2032     uint8_t mOptionsOverride;
2033 };
2034
2035 /*
2036  * Command MoveToColorTemperature
2037  */
2038 class ColorControlMoveToColorTemperature : public ModelCommand
2039 {
2040 public:
2041     ColorControlMoveToColorTemperature() : ModelCommand("move-to-color-temperature")
2042     {
2043         AddArgument("colorTemperature", 0, UINT16_MAX, &mColorTemperature);
2044         AddArgument("transitionTime", 0, UINT16_MAX, &mTransitionTime);
2045         AddArgument("optionsMask", 0, UINT8_MAX, &mOptionsMask);
2046         AddArgument("optionsOverride", 0, UINT8_MAX, &mOptionsOverride);
2047         ModelCommand::AddArguments();
2048     }
2049     ~ColorControlMoveToColorTemperature()
2050     {
2051         delete onSuccessCallback;
2052         delete onFailureCallback;
2053     }
2054
2055     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
2056     {
2057         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x0A) on endpoint %" PRIu16, endpointId);
2058
2059         chip::Controller::ColorControlCluster cluster;
2060         cluster.Associate(device, endpointId);
2061         return cluster.MoveToColorTemperature(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mColorTemperature,
2062                                               mTransitionTime, mOptionsMask, mOptionsOverride);
2063     }
2064
2065 private:
2066     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
2067         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
2068     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
2069         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
2070     uint16_t mColorTemperature;
2071     uint16_t mTransitionTime;
2072     uint8_t mOptionsMask;
2073     uint8_t mOptionsOverride;
2074 };
2075
2076 /*
2077  * Command MoveToHue
2078  */
2079 class ColorControlMoveToHue : public ModelCommand
2080 {
2081 public:
2082     ColorControlMoveToHue() : ModelCommand("move-to-hue")
2083     {
2084         AddArgument("hue", 0, UINT8_MAX, &mHue);
2085         AddArgument("direction", 0, UINT8_MAX, &mDirection);
2086         AddArgument("transitionTime", 0, UINT16_MAX, &mTransitionTime);
2087         AddArgument("optionsMask", 0, UINT8_MAX, &mOptionsMask);
2088         AddArgument("optionsOverride", 0, UINT8_MAX, &mOptionsOverride);
2089         ModelCommand::AddArguments();
2090     }
2091     ~ColorControlMoveToHue()
2092     {
2093         delete onSuccessCallback;
2094         delete onFailureCallback;
2095     }
2096
2097     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
2098     {
2099         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
2100
2101         chip::Controller::ColorControlCluster cluster;
2102         cluster.Associate(device, endpointId);
2103         return cluster.MoveToHue(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mHue, mDirection, mTransitionTime,
2104                                  mOptionsMask, mOptionsOverride);
2105     }
2106
2107 private:
2108     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
2109         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
2110     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
2111         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
2112     uint8_t mHue;
2113     uint8_t mDirection;
2114     uint16_t mTransitionTime;
2115     uint8_t mOptionsMask;
2116     uint8_t mOptionsOverride;
2117 };
2118
2119 /*
2120  * Command MoveToHueAndSaturation
2121  */
2122 class ColorControlMoveToHueAndSaturation : public ModelCommand
2123 {
2124 public:
2125     ColorControlMoveToHueAndSaturation() : ModelCommand("move-to-hue-and-saturation")
2126     {
2127         AddArgument("hue", 0, UINT8_MAX, &mHue);
2128         AddArgument("saturation", 0, UINT8_MAX, &mSaturation);
2129         AddArgument("transitionTime", 0, UINT16_MAX, &mTransitionTime);
2130         AddArgument("optionsMask", 0, UINT8_MAX, &mOptionsMask);
2131         AddArgument("optionsOverride", 0, UINT8_MAX, &mOptionsOverride);
2132         ModelCommand::AddArguments();
2133     }
2134     ~ColorControlMoveToHueAndSaturation()
2135     {
2136         delete onSuccessCallback;
2137         delete onFailureCallback;
2138     }
2139
2140     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
2141     {
2142         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x06) on endpoint %" PRIu16, endpointId);
2143
2144         chip::Controller::ColorControlCluster cluster;
2145         cluster.Associate(device, endpointId);
2146         return cluster.MoveToHueAndSaturation(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mHue, mSaturation,
2147                                               mTransitionTime, mOptionsMask, mOptionsOverride);
2148     }
2149
2150 private:
2151     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
2152         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
2153     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
2154         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
2155     uint8_t mHue;
2156     uint8_t mSaturation;
2157     uint16_t mTransitionTime;
2158     uint8_t mOptionsMask;
2159     uint8_t mOptionsOverride;
2160 };
2161
2162 /*
2163  * Command MoveToSaturation
2164  */
2165 class ColorControlMoveToSaturation : public ModelCommand
2166 {
2167 public:
2168     ColorControlMoveToSaturation() : ModelCommand("move-to-saturation")
2169     {
2170         AddArgument("saturation", 0, UINT8_MAX, &mSaturation);
2171         AddArgument("transitionTime", 0, UINT16_MAX, &mTransitionTime);
2172         AddArgument("optionsMask", 0, UINT8_MAX, &mOptionsMask);
2173         AddArgument("optionsOverride", 0, UINT8_MAX, &mOptionsOverride);
2174         ModelCommand::AddArguments();
2175     }
2176     ~ColorControlMoveToSaturation()
2177     {
2178         delete onSuccessCallback;
2179         delete onFailureCallback;
2180     }
2181
2182     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
2183     {
2184         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x03) on endpoint %" PRIu16, endpointId);
2185
2186         chip::Controller::ColorControlCluster cluster;
2187         cluster.Associate(device, endpointId);
2188         return cluster.MoveToSaturation(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mSaturation, mTransitionTime,
2189                                         mOptionsMask, mOptionsOverride);
2190     }
2191
2192 private:
2193     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
2194         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
2195     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
2196         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
2197     uint8_t mSaturation;
2198     uint16_t mTransitionTime;
2199     uint8_t mOptionsMask;
2200     uint8_t mOptionsOverride;
2201 };
2202
2203 /*
2204  * Command StepColor
2205  */
2206 class ColorControlStepColor : public ModelCommand
2207 {
2208 public:
2209     ColorControlStepColor() : ModelCommand("step-color")
2210     {
2211         AddArgument("stepX", INT16_MIN, INT16_MAX, &mStepX);
2212         AddArgument("stepY", INT16_MIN, INT16_MAX, &mStepY);
2213         AddArgument("transitionTime", 0, UINT16_MAX, &mTransitionTime);
2214         AddArgument("optionsMask", 0, UINT8_MAX, &mOptionsMask);
2215         AddArgument("optionsOverride", 0, UINT8_MAX, &mOptionsOverride);
2216         ModelCommand::AddArguments();
2217     }
2218     ~ColorControlStepColor()
2219     {
2220         delete onSuccessCallback;
2221         delete onFailureCallback;
2222     }
2223
2224     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
2225     {
2226         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x09) on endpoint %" PRIu16, endpointId);
2227
2228         chip::Controller::ColorControlCluster cluster;
2229         cluster.Associate(device, endpointId);
2230         return cluster.StepColor(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mStepX, mStepY, mTransitionTime,
2231                                  mOptionsMask, mOptionsOverride);
2232     }
2233
2234 private:
2235     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
2236         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
2237     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
2238         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
2239     int16_t mStepX;
2240     int16_t mStepY;
2241     uint16_t mTransitionTime;
2242     uint8_t mOptionsMask;
2243     uint8_t mOptionsOverride;
2244 };
2245
2246 /*
2247  * Command StepColorTemperature
2248  */
2249 class ColorControlStepColorTemperature : public ModelCommand
2250 {
2251 public:
2252     ColorControlStepColorTemperature() : ModelCommand("step-color-temperature")
2253     {
2254         AddArgument("stepMode", 0, UINT8_MAX, &mStepMode);
2255         AddArgument("stepSize", 0, UINT16_MAX, &mStepSize);
2256         AddArgument("transitionTime", 0, UINT16_MAX, &mTransitionTime);
2257         AddArgument("colorTemperatureMinimum", 0, UINT16_MAX, &mColorTemperatureMinimum);
2258         AddArgument("colorTemperatureMaximum", 0, UINT16_MAX, &mColorTemperatureMaximum);
2259         AddArgument("optionsMask", 0, UINT8_MAX, &mOptionsMask);
2260         AddArgument("optionsOverride", 0, UINT8_MAX, &mOptionsOverride);
2261         ModelCommand::AddArguments();
2262     }
2263     ~ColorControlStepColorTemperature()
2264     {
2265         delete onSuccessCallback;
2266         delete onFailureCallback;
2267     }
2268
2269     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
2270     {
2271         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x4C) on endpoint %" PRIu16, endpointId);
2272
2273         chip::Controller::ColorControlCluster cluster;
2274         cluster.Associate(device, endpointId);
2275         return cluster.StepColorTemperature(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mStepMode, mStepSize,
2276                                             mTransitionTime, mColorTemperatureMinimum, mColorTemperatureMaximum, mOptionsMask,
2277                                             mOptionsOverride);
2278     }
2279
2280 private:
2281     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
2282         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
2283     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
2284         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
2285     uint8_t mStepMode;
2286     uint16_t mStepSize;
2287     uint16_t mTransitionTime;
2288     uint16_t mColorTemperatureMinimum;
2289     uint16_t mColorTemperatureMaximum;
2290     uint8_t mOptionsMask;
2291     uint8_t mOptionsOverride;
2292 };
2293
2294 /*
2295  * Command StepHue
2296  */
2297 class ColorControlStepHue : public ModelCommand
2298 {
2299 public:
2300     ColorControlStepHue() : ModelCommand("step-hue")
2301     {
2302         AddArgument("stepMode", 0, UINT8_MAX, &mStepMode);
2303         AddArgument("stepSize", 0, UINT8_MAX, &mStepSize);
2304         AddArgument("transitionTime", 0, UINT8_MAX, &mTransitionTime);
2305         AddArgument("optionsMask", 0, UINT8_MAX, &mOptionsMask);
2306         AddArgument("optionsOverride", 0, UINT8_MAX, &mOptionsOverride);
2307         ModelCommand::AddArguments();
2308     }
2309     ~ColorControlStepHue()
2310     {
2311         delete onSuccessCallback;
2312         delete onFailureCallback;
2313     }
2314
2315     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
2316     {
2317         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x02) on endpoint %" PRIu16, endpointId);
2318
2319         chip::Controller::ColorControlCluster cluster;
2320         cluster.Associate(device, endpointId);
2321         return cluster.StepHue(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mStepMode, mStepSize, mTransitionTime,
2322                                mOptionsMask, mOptionsOverride);
2323     }
2324
2325 private:
2326     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
2327         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
2328     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
2329         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
2330     uint8_t mStepMode;
2331     uint8_t mStepSize;
2332     uint8_t mTransitionTime;
2333     uint8_t mOptionsMask;
2334     uint8_t mOptionsOverride;
2335 };
2336
2337 /*
2338  * Command StepSaturation
2339  */
2340 class ColorControlStepSaturation : public ModelCommand
2341 {
2342 public:
2343     ColorControlStepSaturation() : ModelCommand("step-saturation")
2344     {
2345         AddArgument("stepMode", 0, UINT8_MAX, &mStepMode);
2346         AddArgument("stepSize", 0, UINT8_MAX, &mStepSize);
2347         AddArgument("transitionTime", 0, UINT8_MAX, &mTransitionTime);
2348         AddArgument("optionsMask", 0, UINT8_MAX, &mOptionsMask);
2349         AddArgument("optionsOverride", 0, UINT8_MAX, &mOptionsOverride);
2350         ModelCommand::AddArguments();
2351     }
2352     ~ColorControlStepSaturation()
2353     {
2354         delete onSuccessCallback;
2355         delete onFailureCallback;
2356     }
2357
2358     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
2359     {
2360         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x05) on endpoint %" PRIu16, endpointId);
2361
2362         chip::Controller::ColorControlCluster cluster;
2363         cluster.Associate(device, endpointId);
2364         return cluster.StepSaturation(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mStepMode, mStepSize,
2365                                       mTransitionTime, mOptionsMask, mOptionsOverride);
2366     }
2367
2368 private:
2369     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
2370         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
2371     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
2372         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
2373     uint8_t mStepMode;
2374     uint8_t mStepSize;
2375     uint8_t mTransitionTime;
2376     uint8_t mOptionsMask;
2377     uint8_t mOptionsOverride;
2378 };
2379
2380 /*
2381  * Command StopMoveStep
2382  */
2383 class ColorControlStopMoveStep : public ModelCommand
2384 {
2385 public:
2386     ColorControlStopMoveStep() : ModelCommand("stop-move-step")
2387     {
2388         AddArgument("optionsMask", 0, UINT8_MAX, &mOptionsMask);
2389         AddArgument("optionsOverride", 0, UINT8_MAX, &mOptionsOverride);
2390         ModelCommand::AddArguments();
2391     }
2392     ~ColorControlStopMoveStep()
2393     {
2394         delete onSuccessCallback;
2395         delete onFailureCallback;
2396     }
2397
2398     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
2399     {
2400         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x47) on endpoint %" PRIu16, endpointId);
2401
2402         chip::Controller::ColorControlCluster cluster;
2403         cluster.Associate(device, endpointId);
2404         return cluster.StopMoveStep(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mOptionsMask, mOptionsOverride);
2405     }
2406
2407 private:
2408     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
2409         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
2410     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
2411         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
2412     uint8_t mOptionsMask;
2413     uint8_t mOptionsOverride;
2414 };
2415
2416 /*
2417  * Discover Attributes
2418  */
2419 class DiscoverColorControlAttributes : public ModelCommand
2420 {
2421 public:
2422     DiscoverColorControlAttributes() : ModelCommand("discover") { ModelCommand::AddArguments(); }
2423
2424     ~DiscoverColorControlAttributes()
2425     {
2426         delete onSuccessCallback;
2427         delete onFailureCallback;
2428     }
2429
2430     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
2431     {
2432         ChipLogProgress(chipTool, "Sending cluster (0x0000) command (0x0C) on endpoint %" PRIu16, endpointId);
2433
2434         chip::Controller::ColorControlCluster cluster;
2435         cluster.Associate(device, endpointId);
2436         return cluster.DiscoverAttributes(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
2437     }
2438
2439 private:
2440     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
2441         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
2442     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
2443         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
2444 };
2445
2446 /*
2447  * Attribute CurrentHue
2448  */
2449 class ReadColorControlCurrentHue : public ModelCommand
2450 {
2451 public:
2452     ReadColorControlCurrentHue() : ModelCommand("read")
2453     {
2454         AddArgument("attr-name", "current-hue");
2455         ModelCommand::AddArguments();
2456     }
2457
2458     ~ReadColorControlCurrentHue()
2459     {
2460         delete onSuccessCallback;
2461         delete onFailureCallback;
2462     }
2463
2464     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
2465     {
2466         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
2467
2468         chip::Controller::ColorControlCluster cluster;
2469         cluster.Associate(device, endpointId);
2470         return cluster.ReadAttributeCurrentHue(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
2471     }
2472
2473 private:
2474     chip::Callback::Callback<Int8uAttributeCallback> * onSuccessCallback =
2475         new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
2476     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
2477         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
2478 };
2479
2480 class ReportColorControlCurrentHue : public ModelCommand
2481 {
2482 public:
2483     ReportColorControlCurrentHue() : ModelCommand("report")
2484     {
2485         AddArgument("attr-name", "current-hue");
2486         AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval);
2487         AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval);
2488         AddArgument("change", 0, UINT8_MAX, &mChange);
2489         ModelCommand::AddArguments();
2490     }
2491
2492     ~ReportColorControlCurrentHue()
2493     {
2494         delete onSuccessCallback;
2495         delete onFailureCallback;
2496         delete onReportCallback;
2497     }
2498
2499     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
2500     {
2501         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x06) on endpoint %" PRIu16, endpointId);
2502
2503         chip::Controller::ColorControlCluster cluster;
2504         cluster.Associate(device, endpointId);
2505
2506         CHIP_ERROR err = cluster.ReportAttributeCurrentHue(onReportCallback->Cancel());
2507         if (err != CHIP_NO_ERROR)
2508         {
2509             return err;
2510         }
2511
2512         return cluster.ConfigureAttributeCurrentHue(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval,
2513                                                     mMaxInterval, mChange);
2514     }
2515
2516 private:
2517     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
2518         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
2519     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
2520         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
2521     chip::Callback::Callback<Int8uAttributeCallback> * onReportCallback =
2522         new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
2523     uint16_t mMinInterval;
2524     uint16_t mMaxInterval;
2525     uint8_t mChange;
2526 };
2527
2528 /*
2529  * Attribute CurrentSaturation
2530  */
2531 class ReadColorControlCurrentSaturation : public ModelCommand
2532 {
2533 public:
2534     ReadColorControlCurrentSaturation() : ModelCommand("read")
2535     {
2536         AddArgument("attr-name", "current-saturation");
2537         ModelCommand::AddArguments();
2538     }
2539
2540     ~ReadColorControlCurrentSaturation()
2541     {
2542         delete onSuccessCallback;
2543         delete onFailureCallback;
2544     }
2545
2546     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
2547     {
2548         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
2549
2550         chip::Controller::ColorControlCluster cluster;
2551         cluster.Associate(device, endpointId);
2552         return cluster.ReadAttributeCurrentSaturation(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
2553     }
2554
2555 private:
2556     chip::Callback::Callback<Int8uAttributeCallback> * onSuccessCallback =
2557         new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
2558     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
2559         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
2560 };
2561
2562 class ReportColorControlCurrentSaturation : public ModelCommand
2563 {
2564 public:
2565     ReportColorControlCurrentSaturation() : ModelCommand("report")
2566     {
2567         AddArgument("attr-name", "current-saturation");
2568         AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval);
2569         AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval);
2570         AddArgument("change", 0, UINT8_MAX, &mChange);
2571         ModelCommand::AddArguments();
2572     }
2573
2574     ~ReportColorControlCurrentSaturation()
2575     {
2576         delete onSuccessCallback;
2577         delete onFailureCallback;
2578         delete onReportCallback;
2579     }
2580
2581     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
2582     {
2583         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x06) on endpoint %" PRIu16, endpointId);
2584
2585         chip::Controller::ColorControlCluster cluster;
2586         cluster.Associate(device, endpointId);
2587
2588         CHIP_ERROR err = cluster.ReportAttributeCurrentSaturation(onReportCallback->Cancel());
2589         if (err != CHIP_NO_ERROR)
2590         {
2591             return err;
2592         }
2593
2594         return cluster.ConfigureAttributeCurrentSaturation(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval,
2595                                                            mMaxInterval, mChange);
2596     }
2597
2598 private:
2599     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
2600         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
2601     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
2602         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
2603     chip::Callback::Callback<Int8uAttributeCallback> * onReportCallback =
2604         new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
2605     uint16_t mMinInterval;
2606     uint16_t mMaxInterval;
2607     uint8_t mChange;
2608 };
2609
2610 /*
2611  * Attribute RemainingTime
2612  */
2613 class ReadColorControlRemainingTime : public ModelCommand
2614 {
2615 public:
2616     ReadColorControlRemainingTime() : ModelCommand("read")
2617     {
2618         AddArgument("attr-name", "remaining-time");
2619         ModelCommand::AddArguments();
2620     }
2621
2622     ~ReadColorControlRemainingTime()
2623     {
2624         delete onSuccessCallback;
2625         delete onFailureCallback;
2626     }
2627
2628     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
2629     {
2630         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
2631
2632         chip::Controller::ColorControlCluster cluster;
2633         cluster.Associate(device, endpointId);
2634         return cluster.ReadAttributeRemainingTime(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
2635     }
2636
2637 private:
2638     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
2639         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
2640     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
2641         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
2642 };
2643
2644 /*
2645  * Attribute CurrentX
2646  */
2647 class ReadColorControlCurrentX : public ModelCommand
2648 {
2649 public:
2650     ReadColorControlCurrentX() : ModelCommand("read")
2651     {
2652         AddArgument("attr-name", "current-x");
2653         ModelCommand::AddArguments();
2654     }
2655
2656     ~ReadColorControlCurrentX()
2657     {
2658         delete onSuccessCallback;
2659         delete onFailureCallback;
2660     }
2661
2662     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
2663     {
2664         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
2665
2666         chip::Controller::ColorControlCluster cluster;
2667         cluster.Associate(device, endpointId);
2668         return cluster.ReadAttributeCurrentX(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
2669     }
2670
2671 private:
2672     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
2673         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
2674     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
2675         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
2676 };
2677
2678 class ReportColorControlCurrentX : public ModelCommand
2679 {
2680 public:
2681     ReportColorControlCurrentX() : ModelCommand("report")
2682     {
2683         AddArgument("attr-name", "current-x");
2684         AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval);
2685         AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval);
2686         AddArgument("change", 0, UINT16_MAX, &mChange);
2687         ModelCommand::AddArguments();
2688     }
2689
2690     ~ReportColorControlCurrentX()
2691     {
2692         delete onSuccessCallback;
2693         delete onFailureCallback;
2694         delete onReportCallback;
2695     }
2696
2697     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
2698     {
2699         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x06) on endpoint %" PRIu16, endpointId);
2700
2701         chip::Controller::ColorControlCluster cluster;
2702         cluster.Associate(device, endpointId);
2703
2704         CHIP_ERROR err = cluster.ReportAttributeCurrentX(onReportCallback->Cancel());
2705         if (err != CHIP_NO_ERROR)
2706         {
2707             return err;
2708         }
2709
2710         return cluster.ConfigureAttributeCurrentX(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval,
2711                                                   mMaxInterval, mChange);
2712     }
2713
2714 private:
2715     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
2716         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
2717     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
2718         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
2719     chip::Callback::Callback<Int16uAttributeCallback> * onReportCallback =
2720         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
2721     uint16_t mMinInterval;
2722     uint16_t mMaxInterval;
2723     uint16_t mChange;
2724 };
2725
2726 /*
2727  * Attribute CurrentY
2728  */
2729 class ReadColorControlCurrentY : public ModelCommand
2730 {
2731 public:
2732     ReadColorControlCurrentY() : ModelCommand("read")
2733     {
2734         AddArgument("attr-name", "current-y");
2735         ModelCommand::AddArguments();
2736     }
2737
2738     ~ReadColorControlCurrentY()
2739     {
2740         delete onSuccessCallback;
2741         delete onFailureCallback;
2742     }
2743
2744     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
2745     {
2746         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
2747
2748         chip::Controller::ColorControlCluster cluster;
2749         cluster.Associate(device, endpointId);
2750         return cluster.ReadAttributeCurrentY(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
2751     }
2752
2753 private:
2754     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
2755         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
2756     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
2757         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
2758 };
2759
2760 class ReportColorControlCurrentY : public ModelCommand
2761 {
2762 public:
2763     ReportColorControlCurrentY() : ModelCommand("report")
2764     {
2765         AddArgument("attr-name", "current-y");
2766         AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval);
2767         AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval);
2768         AddArgument("change", 0, UINT16_MAX, &mChange);
2769         ModelCommand::AddArguments();
2770     }
2771
2772     ~ReportColorControlCurrentY()
2773     {
2774         delete onSuccessCallback;
2775         delete onFailureCallback;
2776         delete onReportCallback;
2777     }
2778
2779     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
2780     {
2781         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x06) on endpoint %" PRIu16, endpointId);
2782
2783         chip::Controller::ColorControlCluster cluster;
2784         cluster.Associate(device, endpointId);
2785
2786         CHIP_ERROR err = cluster.ReportAttributeCurrentY(onReportCallback->Cancel());
2787         if (err != CHIP_NO_ERROR)
2788         {
2789             return err;
2790         }
2791
2792         return cluster.ConfigureAttributeCurrentY(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval,
2793                                                   mMaxInterval, mChange);
2794     }
2795
2796 private:
2797     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
2798         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
2799     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
2800         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
2801     chip::Callback::Callback<Int16uAttributeCallback> * onReportCallback =
2802         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
2803     uint16_t mMinInterval;
2804     uint16_t mMaxInterval;
2805     uint16_t mChange;
2806 };
2807
2808 /*
2809  * Attribute DriftCompensation
2810  */
2811 class ReadColorControlDriftCompensation : public ModelCommand
2812 {
2813 public:
2814     ReadColorControlDriftCompensation() : ModelCommand("read")
2815     {
2816         AddArgument("attr-name", "drift-compensation");
2817         ModelCommand::AddArguments();
2818     }
2819
2820     ~ReadColorControlDriftCompensation()
2821     {
2822         delete onSuccessCallback;
2823         delete onFailureCallback;
2824     }
2825
2826     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
2827     {
2828         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
2829
2830         chip::Controller::ColorControlCluster cluster;
2831         cluster.Associate(device, endpointId);
2832         return cluster.ReadAttributeDriftCompensation(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
2833     }
2834
2835 private:
2836     chip::Callback::Callback<Int8uAttributeCallback> * onSuccessCallback =
2837         new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
2838     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
2839         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
2840 };
2841
2842 /*
2843  * Attribute CompensationText
2844  */
2845 class ReadColorControlCompensationText : public ModelCommand
2846 {
2847 public:
2848     ReadColorControlCompensationText() : ModelCommand("read")
2849     {
2850         AddArgument("attr-name", "compensation-text");
2851         ModelCommand::AddArguments();
2852     }
2853
2854     ~ReadColorControlCompensationText()
2855     {
2856         delete onSuccessCallback;
2857         delete onFailureCallback;
2858     }
2859
2860     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
2861     {
2862         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
2863
2864         chip::Controller::ColorControlCluster cluster;
2865         cluster.Associate(device, endpointId);
2866         return cluster.ReadAttributeCompensationText(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
2867     }
2868
2869 private:
2870     chip::Callback::Callback<StringAttributeCallback> * onSuccessCallback =
2871         new chip::Callback::Callback<StringAttributeCallback>(OnStringAttributeResponse, this);
2872     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
2873         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
2874 };
2875
2876 /*
2877  * Attribute ColorTemperature
2878  */
2879 class ReadColorControlColorTemperature : public ModelCommand
2880 {
2881 public:
2882     ReadColorControlColorTemperature() : ModelCommand("read")
2883     {
2884         AddArgument("attr-name", "color-temperature");
2885         ModelCommand::AddArguments();
2886     }
2887
2888     ~ReadColorControlColorTemperature()
2889     {
2890         delete onSuccessCallback;
2891         delete onFailureCallback;
2892     }
2893
2894     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
2895     {
2896         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
2897
2898         chip::Controller::ColorControlCluster cluster;
2899         cluster.Associate(device, endpointId);
2900         return cluster.ReadAttributeColorTemperature(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
2901     }
2902
2903 private:
2904     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
2905         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
2906     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
2907         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
2908 };
2909
2910 class ReportColorControlColorTemperature : public ModelCommand
2911 {
2912 public:
2913     ReportColorControlColorTemperature() : ModelCommand("report")
2914     {
2915         AddArgument("attr-name", "color-temperature");
2916         AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval);
2917         AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval);
2918         AddArgument("change", 0, UINT16_MAX, &mChange);
2919         ModelCommand::AddArguments();
2920     }
2921
2922     ~ReportColorControlColorTemperature()
2923     {
2924         delete onSuccessCallback;
2925         delete onFailureCallback;
2926         delete onReportCallback;
2927     }
2928
2929     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
2930     {
2931         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x06) on endpoint %" PRIu16, endpointId);
2932
2933         chip::Controller::ColorControlCluster cluster;
2934         cluster.Associate(device, endpointId);
2935
2936         CHIP_ERROR err = cluster.ReportAttributeColorTemperature(onReportCallback->Cancel());
2937         if (err != CHIP_NO_ERROR)
2938         {
2939             return err;
2940         }
2941
2942         return cluster.ConfigureAttributeColorTemperature(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval,
2943                                                           mMaxInterval, mChange);
2944     }
2945
2946 private:
2947     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
2948         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
2949     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
2950         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
2951     chip::Callback::Callback<Int16uAttributeCallback> * onReportCallback =
2952         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
2953     uint16_t mMinInterval;
2954     uint16_t mMaxInterval;
2955     uint16_t mChange;
2956 };
2957
2958 /*
2959  * Attribute ColorMode
2960  */
2961 class ReadColorControlColorMode : public ModelCommand
2962 {
2963 public:
2964     ReadColorControlColorMode() : ModelCommand("read")
2965     {
2966         AddArgument("attr-name", "color-mode");
2967         ModelCommand::AddArguments();
2968     }
2969
2970     ~ReadColorControlColorMode()
2971     {
2972         delete onSuccessCallback;
2973         delete onFailureCallback;
2974     }
2975
2976     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
2977     {
2978         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
2979
2980         chip::Controller::ColorControlCluster cluster;
2981         cluster.Associate(device, endpointId);
2982         return cluster.ReadAttributeColorMode(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
2983     }
2984
2985 private:
2986     chip::Callback::Callback<Int8uAttributeCallback> * onSuccessCallback =
2987         new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
2988     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
2989         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
2990 };
2991
2992 /*
2993  * Attribute ColorControlOptions
2994  */
2995 class ReadColorControlColorControlOptions : public ModelCommand
2996 {
2997 public:
2998     ReadColorControlColorControlOptions() : ModelCommand("read")
2999     {
3000         AddArgument("attr-name", "color-control-options");
3001         ModelCommand::AddArguments();
3002     }
3003
3004     ~ReadColorControlColorControlOptions()
3005     {
3006         delete onSuccessCallback;
3007         delete onFailureCallback;
3008     }
3009
3010     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
3011     {
3012         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
3013
3014         chip::Controller::ColorControlCluster cluster;
3015         cluster.Associate(device, endpointId);
3016         return cluster.ReadAttributeColorControlOptions(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
3017     }
3018
3019 private:
3020     chip::Callback::Callback<Int8uAttributeCallback> * onSuccessCallback =
3021         new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
3022     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
3023         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
3024 };
3025
3026 class WriteColorControlColorControlOptions : public ModelCommand
3027 {
3028 public:
3029     WriteColorControlColorControlOptions() : ModelCommand("write")
3030     {
3031         AddArgument("attr-name", "color-control-options");
3032         AddArgument("attr-value", 0, UINT8_MAX, &mValue);
3033         ModelCommand::AddArguments();
3034     }
3035
3036     ~WriteColorControlColorControlOptions()
3037     {
3038         delete onSuccessCallback;
3039         delete onFailureCallback;
3040     }
3041
3042     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
3043     {
3044         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x01) on endpoint %" PRIu16, endpointId);
3045
3046         chip::Controller::ColorControlCluster cluster;
3047         cluster.Associate(device, endpointId);
3048         return cluster.WriteAttributeColorControlOptions(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue);
3049     }
3050
3051 private:
3052     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
3053         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
3054     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
3055         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
3056     uint8_t mValue;
3057 };
3058
3059 /*
3060  * Attribute NumberOfPrimaries
3061  */
3062 class ReadColorControlNumberOfPrimaries : public ModelCommand
3063 {
3064 public:
3065     ReadColorControlNumberOfPrimaries() : ModelCommand("read")
3066     {
3067         AddArgument("attr-name", "number-of-primaries");
3068         ModelCommand::AddArguments();
3069     }
3070
3071     ~ReadColorControlNumberOfPrimaries()
3072     {
3073         delete onSuccessCallback;
3074         delete onFailureCallback;
3075     }
3076
3077     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
3078     {
3079         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
3080
3081         chip::Controller::ColorControlCluster cluster;
3082         cluster.Associate(device, endpointId);
3083         return cluster.ReadAttributeNumberOfPrimaries(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
3084     }
3085
3086 private:
3087     chip::Callback::Callback<Int8uAttributeCallback> * onSuccessCallback =
3088         new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
3089     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
3090         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
3091 };
3092
3093 /*
3094  * Attribute Primary1X
3095  */
3096 class ReadColorControlPrimary1X : public ModelCommand
3097 {
3098 public:
3099     ReadColorControlPrimary1X() : ModelCommand("read")
3100     {
3101         AddArgument("attr-name", "primary1x");
3102         ModelCommand::AddArguments();
3103     }
3104
3105     ~ReadColorControlPrimary1X()
3106     {
3107         delete onSuccessCallback;
3108         delete onFailureCallback;
3109     }
3110
3111     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
3112     {
3113         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
3114
3115         chip::Controller::ColorControlCluster cluster;
3116         cluster.Associate(device, endpointId);
3117         return cluster.ReadAttributePrimary1X(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
3118     }
3119
3120 private:
3121     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
3122         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
3123     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
3124         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
3125 };
3126
3127 /*
3128  * Attribute Primary1Y
3129  */
3130 class ReadColorControlPrimary1Y : public ModelCommand
3131 {
3132 public:
3133     ReadColorControlPrimary1Y() : ModelCommand("read")
3134     {
3135         AddArgument("attr-name", "primary1y");
3136         ModelCommand::AddArguments();
3137     }
3138
3139     ~ReadColorControlPrimary1Y()
3140     {
3141         delete onSuccessCallback;
3142         delete onFailureCallback;
3143     }
3144
3145     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
3146     {
3147         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
3148
3149         chip::Controller::ColorControlCluster cluster;
3150         cluster.Associate(device, endpointId);
3151         return cluster.ReadAttributePrimary1Y(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
3152     }
3153
3154 private:
3155     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
3156         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
3157     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
3158         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
3159 };
3160
3161 /*
3162  * Attribute Primary1Intensity
3163  */
3164 class ReadColorControlPrimary1Intensity : public ModelCommand
3165 {
3166 public:
3167     ReadColorControlPrimary1Intensity() : ModelCommand("read")
3168     {
3169         AddArgument("attr-name", "primary1intensity");
3170         ModelCommand::AddArguments();
3171     }
3172
3173     ~ReadColorControlPrimary1Intensity()
3174     {
3175         delete onSuccessCallback;
3176         delete onFailureCallback;
3177     }
3178
3179     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
3180     {
3181         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
3182
3183         chip::Controller::ColorControlCluster cluster;
3184         cluster.Associate(device, endpointId);
3185         return cluster.ReadAttributePrimary1Intensity(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
3186     }
3187
3188 private:
3189     chip::Callback::Callback<Int8uAttributeCallback> * onSuccessCallback =
3190         new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
3191     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
3192         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
3193 };
3194
3195 /*
3196  * Attribute Primary2X
3197  */
3198 class ReadColorControlPrimary2X : public ModelCommand
3199 {
3200 public:
3201     ReadColorControlPrimary2X() : ModelCommand("read")
3202     {
3203         AddArgument("attr-name", "primary2x");
3204         ModelCommand::AddArguments();
3205     }
3206
3207     ~ReadColorControlPrimary2X()
3208     {
3209         delete onSuccessCallback;
3210         delete onFailureCallback;
3211     }
3212
3213     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
3214     {
3215         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
3216
3217         chip::Controller::ColorControlCluster cluster;
3218         cluster.Associate(device, endpointId);
3219         return cluster.ReadAttributePrimary2X(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
3220     }
3221
3222 private:
3223     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
3224         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
3225     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
3226         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
3227 };
3228
3229 /*
3230  * Attribute Primary2Y
3231  */
3232 class ReadColorControlPrimary2Y : public ModelCommand
3233 {
3234 public:
3235     ReadColorControlPrimary2Y() : ModelCommand("read")
3236     {
3237         AddArgument("attr-name", "primary2y");
3238         ModelCommand::AddArguments();
3239     }
3240
3241     ~ReadColorControlPrimary2Y()
3242     {
3243         delete onSuccessCallback;
3244         delete onFailureCallback;
3245     }
3246
3247     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
3248     {
3249         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
3250
3251         chip::Controller::ColorControlCluster cluster;
3252         cluster.Associate(device, endpointId);
3253         return cluster.ReadAttributePrimary2Y(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
3254     }
3255
3256 private:
3257     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
3258         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
3259     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
3260         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
3261 };
3262
3263 /*
3264  * Attribute Primary2Intensity
3265  */
3266 class ReadColorControlPrimary2Intensity : public ModelCommand
3267 {
3268 public:
3269     ReadColorControlPrimary2Intensity() : ModelCommand("read")
3270     {
3271         AddArgument("attr-name", "primary2intensity");
3272         ModelCommand::AddArguments();
3273     }
3274
3275     ~ReadColorControlPrimary2Intensity()
3276     {
3277         delete onSuccessCallback;
3278         delete onFailureCallback;
3279     }
3280
3281     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
3282     {
3283         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
3284
3285         chip::Controller::ColorControlCluster cluster;
3286         cluster.Associate(device, endpointId);
3287         return cluster.ReadAttributePrimary2Intensity(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
3288     }
3289
3290 private:
3291     chip::Callback::Callback<Int8uAttributeCallback> * onSuccessCallback =
3292         new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
3293     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
3294         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
3295 };
3296
3297 /*
3298  * Attribute Primary3X
3299  */
3300 class ReadColorControlPrimary3X : public ModelCommand
3301 {
3302 public:
3303     ReadColorControlPrimary3X() : ModelCommand("read")
3304     {
3305         AddArgument("attr-name", "primary3x");
3306         ModelCommand::AddArguments();
3307     }
3308
3309     ~ReadColorControlPrimary3X()
3310     {
3311         delete onSuccessCallback;
3312         delete onFailureCallback;
3313     }
3314
3315     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
3316     {
3317         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
3318
3319         chip::Controller::ColorControlCluster cluster;
3320         cluster.Associate(device, endpointId);
3321         return cluster.ReadAttributePrimary3X(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
3322     }
3323
3324 private:
3325     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
3326         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
3327     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
3328         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
3329 };
3330
3331 /*
3332  * Attribute Primary3Y
3333  */
3334 class ReadColorControlPrimary3Y : public ModelCommand
3335 {
3336 public:
3337     ReadColorControlPrimary3Y() : ModelCommand("read")
3338     {
3339         AddArgument("attr-name", "primary3y");
3340         ModelCommand::AddArguments();
3341     }
3342
3343     ~ReadColorControlPrimary3Y()
3344     {
3345         delete onSuccessCallback;
3346         delete onFailureCallback;
3347     }
3348
3349     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
3350     {
3351         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
3352
3353         chip::Controller::ColorControlCluster cluster;
3354         cluster.Associate(device, endpointId);
3355         return cluster.ReadAttributePrimary3Y(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
3356     }
3357
3358 private:
3359     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
3360         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
3361     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
3362         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
3363 };
3364
3365 /*
3366  * Attribute Primary3Intensity
3367  */
3368 class ReadColorControlPrimary3Intensity : public ModelCommand
3369 {
3370 public:
3371     ReadColorControlPrimary3Intensity() : ModelCommand("read")
3372     {
3373         AddArgument("attr-name", "primary3intensity");
3374         ModelCommand::AddArguments();
3375     }
3376
3377     ~ReadColorControlPrimary3Intensity()
3378     {
3379         delete onSuccessCallback;
3380         delete onFailureCallback;
3381     }
3382
3383     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
3384     {
3385         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
3386
3387         chip::Controller::ColorControlCluster cluster;
3388         cluster.Associate(device, endpointId);
3389         return cluster.ReadAttributePrimary3Intensity(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
3390     }
3391
3392 private:
3393     chip::Callback::Callback<Int8uAttributeCallback> * onSuccessCallback =
3394         new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
3395     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
3396         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
3397 };
3398
3399 /*
3400  * Attribute Primary4X
3401  */
3402 class ReadColorControlPrimary4X : public ModelCommand
3403 {
3404 public:
3405     ReadColorControlPrimary4X() : ModelCommand("read")
3406     {
3407         AddArgument("attr-name", "primary4x");
3408         ModelCommand::AddArguments();
3409     }
3410
3411     ~ReadColorControlPrimary4X()
3412     {
3413         delete onSuccessCallback;
3414         delete onFailureCallback;
3415     }
3416
3417     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
3418     {
3419         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
3420
3421         chip::Controller::ColorControlCluster cluster;
3422         cluster.Associate(device, endpointId);
3423         return cluster.ReadAttributePrimary4X(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
3424     }
3425
3426 private:
3427     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
3428         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
3429     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
3430         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
3431 };
3432
3433 /*
3434  * Attribute Primary4Y
3435  */
3436 class ReadColorControlPrimary4Y : public ModelCommand
3437 {
3438 public:
3439     ReadColorControlPrimary4Y() : ModelCommand("read")
3440     {
3441         AddArgument("attr-name", "primary4y");
3442         ModelCommand::AddArguments();
3443     }
3444
3445     ~ReadColorControlPrimary4Y()
3446     {
3447         delete onSuccessCallback;
3448         delete onFailureCallback;
3449     }
3450
3451     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
3452     {
3453         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
3454
3455         chip::Controller::ColorControlCluster cluster;
3456         cluster.Associate(device, endpointId);
3457         return cluster.ReadAttributePrimary4Y(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
3458     }
3459
3460 private:
3461     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
3462         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
3463     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
3464         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
3465 };
3466
3467 /*
3468  * Attribute Primary4Intensity
3469  */
3470 class ReadColorControlPrimary4Intensity : public ModelCommand
3471 {
3472 public:
3473     ReadColorControlPrimary4Intensity() : ModelCommand("read")
3474     {
3475         AddArgument("attr-name", "primary4intensity");
3476         ModelCommand::AddArguments();
3477     }
3478
3479     ~ReadColorControlPrimary4Intensity()
3480     {
3481         delete onSuccessCallback;
3482         delete onFailureCallback;
3483     }
3484
3485     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
3486     {
3487         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
3488
3489         chip::Controller::ColorControlCluster cluster;
3490         cluster.Associate(device, endpointId);
3491         return cluster.ReadAttributePrimary4Intensity(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
3492     }
3493
3494 private:
3495     chip::Callback::Callback<Int8uAttributeCallback> * onSuccessCallback =
3496         new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
3497     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
3498         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
3499 };
3500
3501 /*
3502  * Attribute Primary5X
3503  */
3504 class ReadColorControlPrimary5X : public ModelCommand
3505 {
3506 public:
3507     ReadColorControlPrimary5X() : ModelCommand("read")
3508     {
3509         AddArgument("attr-name", "primary5x");
3510         ModelCommand::AddArguments();
3511     }
3512
3513     ~ReadColorControlPrimary5X()
3514     {
3515         delete onSuccessCallback;
3516         delete onFailureCallback;
3517     }
3518
3519     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
3520     {
3521         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
3522
3523         chip::Controller::ColorControlCluster cluster;
3524         cluster.Associate(device, endpointId);
3525         return cluster.ReadAttributePrimary5X(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
3526     }
3527
3528 private:
3529     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
3530         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
3531     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
3532         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
3533 };
3534
3535 /*
3536  * Attribute Primary5Y
3537  */
3538 class ReadColorControlPrimary5Y : public ModelCommand
3539 {
3540 public:
3541     ReadColorControlPrimary5Y() : ModelCommand("read")
3542     {
3543         AddArgument("attr-name", "primary5y");
3544         ModelCommand::AddArguments();
3545     }
3546
3547     ~ReadColorControlPrimary5Y()
3548     {
3549         delete onSuccessCallback;
3550         delete onFailureCallback;
3551     }
3552
3553     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
3554     {
3555         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
3556
3557         chip::Controller::ColorControlCluster cluster;
3558         cluster.Associate(device, endpointId);
3559         return cluster.ReadAttributePrimary5Y(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
3560     }
3561
3562 private:
3563     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
3564         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
3565     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
3566         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
3567 };
3568
3569 /*
3570  * Attribute Primary5Intensity
3571  */
3572 class ReadColorControlPrimary5Intensity : public ModelCommand
3573 {
3574 public:
3575     ReadColorControlPrimary5Intensity() : ModelCommand("read")
3576     {
3577         AddArgument("attr-name", "primary5intensity");
3578         ModelCommand::AddArguments();
3579     }
3580
3581     ~ReadColorControlPrimary5Intensity()
3582     {
3583         delete onSuccessCallback;
3584         delete onFailureCallback;
3585     }
3586
3587     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
3588     {
3589         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
3590
3591         chip::Controller::ColorControlCluster cluster;
3592         cluster.Associate(device, endpointId);
3593         return cluster.ReadAttributePrimary5Intensity(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
3594     }
3595
3596 private:
3597     chip::Callback::Callback<Int8uAttributeCallback> * onSuccessCallback =
3598         new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
3599     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
3600         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
3601 };
3602
3603 /*
3604  * Attribute Primary6X
3605  */
3606 class ReadColorControlPrimary6X : public ModelCommand
3607 {
3608 public:
3609     ReadColorControlPrimary6X() : ModelCommand("read")
3610     {
3611         AddArgument("attr-name", "primary6x");
3612         ModelCommand::AddArguments();
3613     }
3614
3615     ~ReadColorControlPrimary6X()
3616     {
3617         delete onSuccessCallback;
3618         delete onFailureCallback;
3619     }
3620
3621     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
3622     {
3623         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
3624
3625         chip::Controller::ColorControlCluster cluster;
3626         cluster.Associate(device, endpointId);
3627         return cluster.ReadAttributePrimary6X(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
3628     }
3629
3630 private:
3631     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
3632         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
3633     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
3634         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
3635 };
3636
3637 /*
3638  * Attribute Primary6Y
3639  */
3640 class ReadColorControlPrimary6Y : public ModelCommand
3641 {
3642 public:
3643     ReadColorControlPrimary6Y() : ModelCommand("read")
3644     {
3645         AddArgument("attr-name", "primary6y");
3646         ModelCommand::AddArguments();
3647     }
3648
3649     ~ReadColorControlPrimary6Y()
3650     {
3651         delete onSuccessCallback;
3652         delete onFailureCallback;
3653     }
3654
3655     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
3656     {
3657         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
3658
3659         chip::Controller::ColorControlCluster cluster;
3660         cluster.Associate(device, endpointId);
3661         return cluster.ReadAttributePrimary6Y(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
3662     }
3663
3664 private:
3665     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
3666         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
3667     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
3668         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
3669 };
3670
3671 /*
3672  * Attribute Primary6Intensity
3673  */
3674 class ReadColorControlPrimary6Intensity : public ModelCommand
3675 {
3676 public:
3677     ReadColorControlPrimary6Intensity() : ModelCommand("read")
3678     {
3679         AddArgument("attr-name", "primary6intensity");
3680         ModelCommand::AddArguments();
3681     }
3682
3683     ~ReadColorControlPrimary6Intensity()
3684     {
3685         delete onSuccessCallback;
3686         delete onFailureCallback;
3687     }
3688
3689     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
3690     {
3691         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
3692
3693         chip::Controller::ColorControlCluster cluster;
3694         cluster.Associate(device, endpointId);
3695         return cluster.ReadAttributePrimary6Intensity(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
3696     }
3697
3698 private:
3699     chip::Callback::Callback<Int8uAttributeCallback> * onSuccessCallback =
3700         new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
3701     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
3702         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
3703 };
3704
3705 /*
3706  * Attribute WhitePointX
3707  */
3708 class ReadColorControlWhitePointX : public ModelCommand
3709 {
3710 public:
3711     ReadColorControlWhitePointX() : ModelCommand("read")
3712     {
3713         AddArgument("attr-name", "white-point-x");
3714         ModelCommand::AddArguments();
3715     }
3716
3717     ~ReadColorControlWhitePointX()
3718     {
3719         delete onSuccessCallback;
3720         delete onFailureCallback;
3721     }
3722
3723     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
3724     {
3725         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
3726
3727         chip::Controller::ColorControlCluster cluster;
3728         cluster.Associate(device, endpointId);
3729         return cluster.ReadAttributeWhitePointX(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
3730     }
3731
3732 private:
3733     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
3734         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
3735     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
3736         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
3737 };
3738
3739 class WriteColorControlWhitePointX : public ModelCommand
3740 {
3741 public:
3742     WriteColorControlWhitePointX() : ModelCommand("write")
3743     {
3744         AddArgument("attr-name", "white-point-x");
3745         AddArgument("attr-value", 0, UINT16_MAX, &mValue);
3746         ModelCommand::AddArguments();
3747     }
3748
3749     ~WriteColorControlWhitePointX()
3750     {
3751         delete onSuccessCallback;
3752         delete onFailureCallback;
3753     }
3754
3755     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
3756     {
3757         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x01) on endpoint %" PRIu16, endpointId);
3758
3759         chip::Controller::ColorControlCluster cluster;
3760         cluster.Associate(device, endpointId);
3761         return cluster.WriteAttributeWhitePointX(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue);
3762     }
3763
3764 private:
3765     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
3766         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
3767     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
3768         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
3769     uint16_t mValue;
3770 };
3771
3772 /*
3773  * Attribute WhitePointY
3774  */
3775 class ReadColorControlWhitePointY : public ModelCommand
3776 {
3777 public:
3778     ReadColorControlWhitePointY() : ModelCommand("read")
3779     {
3780         AddArgument("attr-name", "white-point-y");
3781         ModelCommand::AddArguments();
3782     }
3783
3784     ~ReadColorControlWhitePointY()
3785     {
3786         delete onSuccessCallback;
3787         delete onFailureCallback;
3788     }
3789
3790     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
3791     {
3792         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
3793
3794         chip::Controller::ColorControlCluster cluster;
3795         cluster.Associate(device, endpointId);
3796         return cluster.ReadAttributeWhitePointY(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
3797     }
3798
3799 private:
3800     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
3801         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
3802     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
3803         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
3804 };
3805
3806 class WriteColorControlWhitePointY : public ModelCommand
3807 {
3808 public:
3809     WriteColorControlWhitePointY() : ModelCommand("write")
3810     {
3811         AddArgument("attr-name", "white-point-y");
3812         AddArgument("attr-value", 0, UINT16_MAX, &mValue);
3813         ModelCommand::AddArguments();
3814     }
3815
3816     ~WriteColorControlWhitePointY()
3817     {
3818         delete onSuccessCallback;
3819         delete onFailureCallback;
3820     }
3821
3822     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
3823     {
3824         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x01) on endpoint %" PRIu16, endpointId);
3825
3826         chip::Controller::ColorControlCluster cluster;
3827         cluster.Associate(device, endpointId);
3828         return cluster.WriteAttributeWhitePointY(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue);
3829     }
3830
3831 private:
3832     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
3833         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
3834     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
3835         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
3836     uint16_t mValue;
3837 };
3838
3839 /*
3840  * Attribute ColorPointRX
3841  */
3842 class ReadColorControlColorPointRX : public ModelCommand
3843 {
3844 public:
3845     ReadColorControlColorPointRX() : ModelCommand("read")
3846     {
3847         AddArgument("attr-name", "color-point-rx");
3848         ModelCommand::AddArguments();
3849     }
3850
3851     ~ReadColorControlColorPointRX()
3852     {
3853         delete onSuccessCallback;
3854         delete onFailureCallback;
3855     }
3856
3857     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
3858     {
3859         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
3860
3861         chip::Controller::ColorControlCluster cluster;
3862         cluster.Associate(device, endpointId);
3863         return cluster.ReadAttributeColorPointRX(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
3864     }
3865
3866 private:
3867     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
3868         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
3869     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
3870         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
3871 };
3872
3873 class WriteColorControlColorPointRX : public ModelCommand
3874 {
3875 public:
3876     WriteColorControlColorPointRX() : ModelCommand("write")
3877     {
3878         AddArgument("attr-name", "color-point-rx");
3879         AddArgument("attr-value", 0, UINT16_MAX, &mValue);
3880         ModelCommand::AddArguments();
3881     }
3882
3883     ~WriteColorControlColorPointRX()
3884     {
3885         delete onSuccessCallback;
3886         delete onFailureCallback;
3887     }
3888
3889     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
3890     {
3891         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x01) on endpoint %" PRIu16, endpointId);
3892
3893         chip::Controller::ColorControlCluster cluster;
3894         cluster.Associate(device, endpointId);
3895         return cluster.WriteAttributeColorPointRX(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue);
3896     }
3897
3898 private:
3899     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
3900         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
3901     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
3902         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
3903     uint16_t mValue;
3904 };
3905
3906 /*
3907  * Attribute ColorPointRY
3908  */
3909 class ReadColorControlColorPointRY : public ModelCommand
3910 {
3911 public:
3912     ReadColorControlColorPointRY() : ModelCommand("read")
3913     {
3914         AddArgument("attr-name", "color-point-ry");
3915         ModelCommand::AddArguments();
3916     }
3917
3918     ~ReadColorControlColorPointRY()
3919     {
3920         delete onSuccessCallback;
3921         delete onFailureCallback;
3922     }
3923
3924     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
3925     {
3926         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
3927
3928         chip::Controller::ColorControlCluster cluster;
3929         cluster.Associate(device, endpointId);
3930         return cluster.ReadAttributeColorPointRY(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
3931     }
3932
3933 private:
3934     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
3935         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
3936     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
3937         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
3938 };
3939
3940 class WriteColorControlColorPointRY : public ModelCommand
3941 {
3942 public:
3943     WriteColorControlColorPointRY() : ModelCommand("write")
3944     {
3945         AddArgument("attr-name", "color-point-ry");
3946         AddArgument("attr-value", 0, UINT16_MAX, &mValue);
3947         ModelCommand::AddArguments();
3948     }
3949
3950     ~WriteColorControlColorPointRY()
3951     {
3952         delete onSuccessCallback;
3953         delete onFailureCallback;
3954     }
3955
3956     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
3957     {
3958         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x01) on endpoint %" PRIu16, endpointId);
3959
3960         chip::Controller::ColorControlCluster cluster;
3961         cluster.Associate(device, endpointId);
3962         return cluster.WriteAttributeColorPointRY(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue);
3963     }
3964
3965 private:
3966     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
3967         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
3968     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
3969         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
3970     uint16_t mValue;
3971 };
3972
3973 /*
3974  * Attribute ColorPointRIntensity
3975  */
3976 class ReadColorControlColorPointRIntensity : public ModelCommand
3977 {
3978 public:
3979     ReadColorControlColorPointRIntensity() : ModelCommand("read")
3980     {
3981         AddArgument("attr-name", "color-point-rintensity");
3982         ModelCommand::AddArguments();
3983     }
3984
3985     ~ReadColorControlColorPointRIntensity()
3986     {
3987         delete onSuccessCallback;
3988         delete onFailureCallback;
3989     }
3990
3991     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
3992     {
3993         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
3994
3995         chip::Controller::ColorControlCluster cluster;
3996         cluster.Associate(device, endpointId);
3997         return cluster.ReadAttributeColorPointRIntensity(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
3998     }
3999
4000 private:
4001     chip::Callback::Callback<Int8uAttributeCallback> * onSuccessCallback =
4002         new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
4003     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
4004         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
4005 };
4006
4007 class WriteColorControlColorPointRIntensity : public ModelCommand
4008 {
4009 public:
4010     WriteColorControlColorPointRIntensity() : ModelCommand("write")
4011     {
4012         AddArgument("attr-name", "color-point-rintensity");
4013         AddArgument("attr-value", 0, UINT8_MAX, &mValue);
4014         ModelCommand::AddArguments();
4015     }
4016
4017     ~WriteColorControlColorPointRIntensity()
4018     {
4019         delete onSuccessCallback;
4020         delete onFailureCallback;
4021     }
4022
4023     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
4024     {
4025         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x01) on endpoint %" PRIu16, endpointId);
4026
4027         chip::Controller::ColorControlCluster cluster;
4028         cluster.Associate(device, endpointId);
4029         return cluster.WriteAttributeColorPointRIntensity(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue);
4030     }
4031
4032 private:
4033     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
4034         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
4035     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
4036         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
4037     uint8_t mValue;
4038 };
4039
4040 /*
4041  * Attribute ColorPointGX
4042  */
4043 class ReadColorControlColorPointGX : public ModelCommand
4044 {
4045 public:
4046     ReadColorControlColorPointGX() : ModelCommand("read")
4047     {
4048         AddArgument("attr-name", "color-point-gx");
4049         ModelCommand::AddArguments();
4050     }
4051
4052     ~ReadColorControlColorPointGX()
4053     {
4054         delete onSuccessCallback;
4055         delete onFailureCallback;
4056     }
4057
4058     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
4059     {
4060         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
4061
4062         chip::Controller::ColorControlCluster cluster;
4063         cluster.Associate(device, endpointId);
4064         return cluster.ReadAttributeColorPointGX(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
4065     }
4066
4067 private:
4068     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
4069         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
4070     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
4071         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
4072 };
4073
4074 class WriteColorControlColorPointGX : public ModelCommand
4075 {
4076 public:
4077     WriteColorControlColorPointGX() : ModelCommand("write")
4078     {
4079         AddArgument("attr-name", "color-point-gx");
4080         AddArgument("attr-value", 0, UINT16_MAX, &mValue);
4081         ModelCommand::AddArguments();
4082     }
4083
4084     ~WriteColorControlColorPointGX()
4085     {
4086         delete onSuccessCallback;
4087         delete onFailureCallback;
4088     }
4089
4090     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
4091     {
4092         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x01) on endpoint %" PRIu16, endpointId);
4093
4094         chip::Controller::ColorControlCluster cluster;
4095         cluster.Associate(device, endpointId);
4096         return cluster.WriteAttributeColorPointGX(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue);
4097     }
4098
4099 private:
4100     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
4101         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
4102     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
4103         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
4104     uint16_t mValue;
4105 };
4106
4107 /*
4108  * Attribute ColorPointGY
4109  */
4110 class ReadColorControlColorPointGY : public ModelCommand
4111 {
4112 public:
4113     ReadColorControlColorPointGY() : ModelCommand("read")
4114     {
4115         AddArgument("attr-name", "color-point-gy");
4116         ModelCommand::AddArguments();
4117     }
4118
4119     ~ReadColorControlColorPointGY()
4120     {
4121         delete onSuccessCallback;
4122         delete onFailureCallback;
4123     }
4124
4125     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
4126     {
4127         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
4128
4129         chip::Controller::ColorControlCluster cluster;
4130         cluster.Associate(device, endpointId);
4131         return cluster.ReadAttributeColorPointGY(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
4132     }
4133
4134 private:
4135     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
4136         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
4137     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
4138         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
4139 };
4140
4141 class WriteColorControlColorPointGY : public ModelCommand
4142 {
4143 public:
4144     WriteColorControlColorPointGY() : ModelCommand("write")
4145     {
4146         AddArgument("attr-name", "color-point-gy");
4147         AddArgument("attr-value", 0, UINT16_MAX, &mValue);
4148         ModelCommand::AddArguments();
4149     }
4150
4151     ~WriteColorControlColorPointGY()
4152     {
4153         delete onSuccessCallback;
4154         delete onFailureCallback;
4155     }
4156
4157     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
4158     {
4159         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x01) on endpoint %" PRIu16, endpointId);
4160
4161         chip::Controller::ColorControlCluster cluster;
4162         cluster.Associate(device, endpointId);
4163         return cluster.WriteAttributeColorPointGY(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue);
4164     }
4165
4166 private:
4167     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
4168         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
4169     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
4170         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
4171     uint16_t mValue;
4172 };
4173
4174 /*
4175  * Attribute ColorPointGIntensity
4176  */
4177 class ReadColorControlColorPointGIntensity : public ModelCommand
4178 {
4179 public:
4180     ReadColorControlColorPointGIntensity() : ModelCommand("read")
4181     {
4182         AddArgument("attr-name", "color-point-gintensity");
4183         ModelCommand::AddArguments();
4184     }
4185
4186     ~ReadColorControlColorPointGIntensity()
4187     {
4188         delete onSuccessCallback;
4189         delete onFailureCallback;
4190     }
4191
4192     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
4193     {
4194         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
4195
4196         chip::Controller::ColorControlCluster cluster;
4197         cluster.Associate(device, endpointId);
4198         return cluster.ReadAttributeColorPointGIntensity(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
4199     }
4200
4201 private:
4202     chip::Callback::Callback<Int8uAttributeCallback> * onSuccessCallback =
4203         new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
4204     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
4205         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
4206 };
4207
4208 class WriteColorControlColorPointGIntensity : public ModelCommand
4209 {
4210 public:
4211     WriteColorControlColorPointGIntensity() : ModelCommand("write")
4212     {
4213         AddArgument("attr-name", "color-point-gintensity");
4214         AddArgument("attr-value", 0, UINT8_MAX, &mValue);
4215         ModelCommand::AddArguments();
4216     }
4217
4218     ~WriteColorControlColorPointGIntensity()
4219     {
4220         delete onSuccessCallback;
4221         delete onFailureCallback;
4222     }
4223
4224     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
4225     {
4226         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x01) on endpoint %" PRIu16, endpointId);
4227
4228         chip::Controller::ColorControlCluster cluster;
4229         cluster.Associate(device, endpointId);
4230         return cluster.WriteAttributeColorPointGIntensity(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue);
4231     }
4232
4233 private:
4234     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
4235         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
4236     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
4237         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
4238     uint8_t mValue;
4239 };
4240
4241 /*
4242  * Attribute ColorPointBX
4243  */
4244 class ReadColorControlColorPointBX : public ModelCommand
4245 {
4246 public:
4247     ReadColorControlColorPointBX() : ModelCommand("read")
4248     {
4249         AddArgument("attr-name", "color-point-bx");
4250         ModelCommand::AddArguments();
4251     }
4252
4253     ~ReadColorControlColorPointBX()
4254     {
4255         delete onSuccessCallback;
4256         delete onFailureCallback;
4257     }
4258
4259     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
4260     {
4261         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
4262
4263         chip::Controller::ColorControlCluster cluster;
4264         cluster.Associate(device, endpointId);
4265         return cluster.ReadAttributeColorPointBX(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
4266     }
4267
4268 private:
4269     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
4270         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
4271     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
4272         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
4273 };
4274
4275 class WriteColorControlColorPointBX : public ModelCommand
4276 {
4277 public:
4278     WriteColorControlColorPointBX() : ModelCommand("write")
4279     {
4280         AddArgument("attr-name", "color-point-bx");
4281         AddArgument("attr-value", 0, UINT16_MAX, &mValue);
4282         ModelCommand::AddArguments();
4283     }
4284
4285     ~WriteColorControlColorPointBX()
4286     {
4287         delete onSuccessCallback;
4288         delete onFailureCallback;
4289     }
4290
4291     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
4292     {
4293         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x01) on endpoint %" PRIu16, endpointId);
4294
4295         chip::Controller::ColorControlCluster cluster;
4296         cluster.Associate(device, endpointId);
4297         return cluster.WriteAttributeColorPointBX(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue);
4298     }
4299
4300 private:
4301     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
4302         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
4303     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
4304         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
4305     uint16_t mValue;
4306 };
4307
4308 /*
4309  * Attribute ColorPointBY
4310  */
4311 class ReadColorControlColorPointBY : public ModelCommand
4312 {
4313 public:
4314     ReadColorControlColorPointBY() : ModelCommand("read")
4315     {
4316         AddArgument("attr-name", "color-point-by");
4317         ModelCommand::AddArguments();
4318     }
4319
4320     ~ReadColorControlColorPointBY()
4321     {
4322         delete onSuccessCallback;
4323         delete onFailureCallback;
4324     }
4325
4326     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
4327     {
4328         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
4329
4330         chip::Controller::ColorControlCluster cluster;
4331         cluster.Associate(device, endpointId);
4332         return cluster.ReadAttributeColorPointBY(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
4333     }
4334
4335 private:
4336     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
4337         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
4338     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
4339         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
4340 };
4341
4342 class WriteColorControlColorPointBY : public ModelCommand
4343 {
4344 public:
4345     WriteColorControlColorPointBY() : ModelCommand("write")
4346     {
4347         AddArgument("attr-name", "color-point-by");
4348         AddArgument("attr-value", 0, UINT16_MAX, &mValue);
4349         ModelCommand::AddArguments();
4350     }
4351
4352     ~WriteColorControlColorPointBY()
4353     {
4354         delete onSuccessCallback;
4355         delete onFailureCallback;
4356     }
4357
4358     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
4359     {
4360         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x01) on endpoint %" PRIu16, endpointId);
4361
4362         chip::Controller::ColorControlCluster cluster;
4363         cluster.Associate(device, endpointId);
4364         return cluster.WriteAttributeColorPointBY(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue);
4365     }
4366
4367 private:
4368     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
4369         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
4370     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
4371         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
4372     uint16_t mValue;
4373 };
4374
4375 /*
4376  * Attribute ColorPointBIntensity
4377  */
4378 class ReadColorControlColorPointBIntensity : public ModelCommand
4379 {
4380 public:
4381     ReadColorControlColorPointBIntensity() : ModelCommand("read")
4382     {
4383         AddArgument("attr-name", "color-point-bintensity");
4384         ModelCommand::AddArguments();
4385     }
4386
4387     ~ReadColorControlColorPointBIntensity()
4388     {
4389         delete onSuccessCallback;
4390         delete onFailureCallback;
4391     }
4392
4393     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
4394     {
4395         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
4396
4397         chip::Controller::ColorControlCluster cluster;
4398         cluster.Associate(device, endpointId);
4399         return cluster.ReadAttributeColorPointBIntensity(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
4400     }
4401
4402 private:
4403     chip::Callback::Callback<Int8uAttributeCallback> * onSuccessCallback =
4404         new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
4405     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
4406         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
4407 };
4408
4409 class WriteColorControlColorPointBIntensity : public ModelCommand
4410 {
4411 public:
4412     WriteColorControlColorPointBIntensity() : ModelCommand("write")
4413     {
4414         AddArgument("attr-name", "color-point-bintensity");
4415         AddArgument("attr-value", 0, UINT8_MAX, &mValue);
4416         ModelCommand::AddArguments();
4417     }
4418
4419     ~WriteColorControlColorPointBIntensity()
4420     {
4421         delete onSuccessCallback;
4422         delete onFailureCallback;
4423     }
4424
4425     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
4426     {
4427         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x01) on endpoint %" PRIu16, endpointId);
4428
4429         chip::Controller::ColorControlCluster cluster;
4430         cluster.Associate(device, endpointId);
4431         return cluster.WriteAttributeColorPointBIntensity(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue);
4432     }
4433
4434 private:
4435     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
4436         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
4437     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
4438         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
4439     uint8_t mValue;
4440 };
4441
4442 /*
4443  * Attribute EnhancedCurrentHue
4444  */
4445 class ReadColorControlEnhancedCurrentHue : public ModelCommand
4446 {
4447 public:
4448     ReadColorControlEnhancedCurrentHue() : ModelCommand("read")
4449     {
4450         AddArgument("attr-name", "enhanced-current-hue");
4451         ModelCommand::AddArguments();
4452     }
4453
4454     ~ReadColorControlEnhancedCurrentHue()
4455     {
4456         delete onSuccessCallback;
4457         delete onFailureCallback;
4458     }
4459
4460     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
4461     {
4462         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
4463
4464         chip::Controller::ColorControlCluster cluster;
4465         cluster.Associate(device, endpointId);
4466         return cluster.ReadAttributeEnhancedCurrentHue(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
4467     }
4468
4469 private:
4470     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
4471         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
4472     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
4473         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
4474 };
4475
4476 /*
4477  * Attribute EnhancedColorMode
4478  */
4479 class ReadColorControlEnhancedColorMode : public ModelCommand
4480 {
4481 public:
4482     ReadColorControlEnhancedColorMode() : ModelCommand("read")
4483     {
4484         AddArgument("attr-name", "enhanced-color-mode");
4485         ModelCommand::AddArguments();
4486     }
4487
4488     ~ReadColorControlEnhancedColorMode()
4489     {
4490         delete onSuccessCallback;
4491         delete onFailureCallback;
4492     }
4493
4494     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
4495     {
4496         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
4497
4498         chip::Controller::ColorControlCluster cluster;
4499         cluster.Associate(device, endpointId);
4500         return cluster.ReadAttributeEnhancedColorMode(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
4501     }
4502
4503 private:
4504     chip::Callback::Callback<Int8uAttributeCallback> * onSuccessCallback =
4505         new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
4506     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
4507         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
4508 };
4509
4510 /*
4511  * Attribute ColorLoopActive
4512  */
4513 class ReadColorControlColorLoopActive : public ModelCommand
4514 {
4515 public:
4516     ReadColorControlColorLoopActive() : ModelCommand("read")
4517     {
4518         AddArgument("attr-name", "color-loop-active");
4519         ModelCommand::AddArguments();
4520     }
4521
4522     ~ReadColorControlColorLoopActive()
4523     {
4524         delete onSuccessCallback;
4525         delete onFailureCallback;
4526     }
4527
4528     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
4529     {
4530         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
4531
4532         chip::Controller::ColorControlCluster cluster;
4533         cluster.Associate(device, endpointId);
4534         return cluster.ReadAttributeColorLoopActive(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
4535     }
4536
4537 private:
4538     chip::Callback::Callback<Int8uAttributeCallback> * onSuccessCallback =
4539         new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
4540     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
4541         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
4542 };
4543
4544 /*
4545  * Attribute ColorLoopDirection
4546  */
4547 class ReadColorControlColorLoopDirection : public ModelCommand
4548 {
4549 public:
4550     ReadColorControlColorLoopDirection() : ModelCommand("read")
4551     {
4552         AddArgument("attr-name", "color-loop-direction");
4553         ModelCommand::AddArguments();
4554     }
4555
4556     ~ReadColorControlColorLoopDirection()
4557     {
4558         delete onSuccessCallback;
4559         delete onFailureCallback;
4560     }
4561
4562     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
4563     {
4564         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
4565
4566         chip::Controller::ColorControlCluster cluster;
4567         cluster.Associate(device, endpointId);
4568         return cluster.ReadAttributeColorLoopDirection(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
4569     }
4570
4571 private:
4572     chip::Callback::Callback<Int8uAttributeCallback> * onSuccessCallback =
4573         new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
4574     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
4575         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
4576 };
4577
4578 /*
4579  * Attribute ColorLoopTime
4580  */
4581 class ReadColorControlColorLoopTime : public ModelCommand
4582 {
4583 public:
4584     ReadColorControlColorLoopTime() : ModelCommand("read")
4585     {
4586         AddArgument("attr-name", "color-loop-time");
4587         ModelCommand::AddArguments();
4588     }
4589
4590     ~ReadColorControlColorLoopTime()
4591     {
4592         delete onSuccessCallback;
4593         delete onFailureCallback;
4594     }
4595
4596     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
4597     {
4598         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
4599
4600         chip::Controller::ColorControlCluster cluster;
4601         cluster.Associate(device, endpointId);
4602         return cluster.ReadAttributeColorLoopTime(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
4603     }
4604
4605 private:
4606     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
4607         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
4608     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
4609         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
4610 };
4611
4612 /*
4613  * Attribute ColorCapabilities
4614  */
4615 class ReadColorControlColorCapabilities : public ModelCommand
4616 {
4617 public:
4618     ReadColorControlColorCapabilities() : ModelCommand("read")
4619     {
4620         AddArgument("attr-name", "color-capabilities");
4621         ModelCommand::AddArguments();
4622     }
4623
4624     ~ReadColorControlColorCapabilities()
4625     {
4626         delete onSuccessCallback;
4627         delete onFailureCallback;
4628     }
4629
4630     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
4631     {
4632         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
4633
4634         chip::Controller::ColorControlCluster cluster;
4635         cluster.Associate(device, endpointId);
4636         return cluster.ReadAttributeColorCapabilities(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
4637     }
4638
4639 private:
4640     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
4641         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
4642     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
4643         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
4644 };
4645
4646 /*
4647  * Attribute ColorTempPhysicalMin
4648  */
4649 class ReadColorControlColorTempPhysicalMin : public ModelCommand
4650 {
4651 public:
4652     ReadColorControlColorTempPhysicalMin() : ModelCommand("read")
4653     {
4654         AddArgument("attr-name", "color-temp-physical-min");
4655         ModelCommand::AddArguments();
4656     }
4657
4658     ~ReadColorControlColorTempPhysicalMin()
4659     {
4660         delete onSuccessCallback;
4661         delete onFailureCallback;
4662     }
4663
4664     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
4665     {
4666         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
4667
4668         chip::Controller::ColorControlCluster cluster;
4669         cluster.Associate(device, endpointId);
4670         return cluster.ReadAttributeColorTempPhysicalMin(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
4671     }
4672
4673 private:
4674     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
4675         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
4676     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
4677         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
4678 };
4679
4680 /*
4681  * Attribute ColorTempPhysicalMax
4682  */
4683 class ReadColorControlColorTempPhysicalMax : public ModelCommand
4684 {
4685 public:
4686     ReadColorControlColorTempPhysicalMax() : ModelCommand("read")
4687     {
4688         AddArgument("attr-name", "color-temp-physical-max");
4689         ModelCommand::AddArguments();
4690     }
4691
4692     ~ReadColorControlColorTempPhysicalMax()
4693     {
4694         delete onSuccessCallback;
4695         delete onFailureCallback;
4696     }
4697
4698     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
4699     {
4700         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
4701
4702         chip::Controller::ColorControlCluster cluster;
4703         cluster.Associate(device, endpointId);
4704         return cluster.ReadAttributeColorTempPhysicalMax(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
4705     }
4706
4707 private:
4708     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
4709         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
4710     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
4711         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
4712 };
4713
4714 /*
4715  * Attribute CoupleColorTempToLevelMinMireds
4716  */
4717 class ReadColorControlCoupleColorTempToLevelMinMireds : public ModelCommand
4718 {
4719 public:
4720     ReadColorControlCoupleColorTempToLevelMinMireds() : ModelCommand("read")
4721     {
4722         AddArgument("attr-name", "couple-color-temp-to-level-min-mireds");
4723         ModelCommand::AddArguments();
4724     }
4725
4726     ~ReadColorControlCoupleColorTempToLevelMinMireds()
4727     {
4728         delete onSuccessCallback;
4729         delete onFailureCallback;
4730     }
4731
4732     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
4733     {
4734         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
4735
4736         chip::Controller::ColorControlCluster cluster;
4737         cluster.Associate(device, endpointId);
4738         return cluster.ReadAttributeCoupleColorTempToLevelMinMireds(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
4739     }
4740
4741 private:
4742     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
4743         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
4744     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
4745         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
4746 };
4747
4748 /*
4749  * Attribute StartUpColorTemperatureMireds
4750  */
4751 class ReadColorControlStartUpColorTemperatureMireds : public ModelCommand
4752 {
4753 public:
4754     ReadColorControlStartUpColorTemperatureMireds() : ModelCommand("read")
4755     {
4756         AddArgument("attr-name", "start-up-color-temperature-mireds");
4757         ModelCommand::AddArguments();
4758     }
4759
4760     ~ReadColorControlStartUpColorTemperatureMireds()
4761     {
4762         delete onSuccessCallback;
4763         delete onFailureCallback;
4764     }
4765
4766     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
4767     {
4768         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
4769
4770         chip::Controller::ColorControlCluster cluster;
4771         cluster.Associate(device, endpointId);
4772         return cluster.ReadAttributeStartUpColorTemperatureMireds(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
4773     }
4774
4775 private:
4776     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
4777         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
4778     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
4779         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
4780 };
4781
4782 class WriteColorControlStartUpColorTemperatureMireds : public ModelCommand
4783 {
4784 public:
4785     WriteColorControlStartUpColorTemperatureMireds() : ModelCommand("write")
4786     {
4787         AddArgument("attr-name", "start-up-color-temperature-mireds");
4788         AddArgument("attr-value", 0, UINT16_MAX, &mValue);
4789         ModelCommand::AddArguments();
4790     }
4791
4792     ~WriteColorControlStartUpColorTemperatureMireds()
4793     {
4794         delete onSuccessCallback;
4795         delete onFailureCallback;
4796     }
4797
4798     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
4799     {
4800         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x01) on endpoint %" PRIu16, endpointId);
4801
4802         chip::Controller::ColorControlCluster cluster;
4803         cluster.Associate(device, endpointId);
4804         return cluster.WriteAttributeStartUpColorTemperatureMireds(onSuccessCallback->Cancel(), onFailureCallback->Cancel(),
4805                                                                    mValue);
4806     }
4807
4808 private:
4809     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
4810         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
4811     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
4812         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
4813     uint16_t mValue;
4814 };
4815
4816 /*
4817  * Attribute ClusterRevision
4818  */
4819 class ReadColorControlClusterRevision : public ModelCommand
4820 {
4821 public:
4822     ReadColorControlClusterRevision() : ModelCommand("read")
4823     {
4824         AddArgument("attr-name", "cluster-revision");
4825         ModelCommand::AddArguments();
4826     }
4827
4828     ~ReadColorControlClusterRevision()
4829     {
4830         delete onSuccessCallback;
4831         delete onFailureCallback;
4832     }
4833
4834     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
4835     {
4836         ChipLogProgress(chipTool, "Sending cluster (0x0300) command (0x00) on endpoint %" PRIu16, endpointId);
4837
4838         chip::Controller::ColorControlCluster cluster;
4839         cluster.Associate(device, endpointId);
4840         return cluster.ReadAttributeClusterRevision(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
4841     }
4842
4843 private:
4844     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
4845         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
4846     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
4847         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
4848 };
4849
4850 /*----------------------------------------------------------------------------*\
4851 | Cluster DoorLock                                                    | 0x0101 |
4852 |------------------------------------------------------------------------------|
4853 | Commands:                                                           |        |
4854 | * ClearAllPins                                                      |   0x08 |
4855 | * ClearAllRfids                                                     |   0x19 |
4856 | * ClearHolidaySchedule                                              |   0x13 |
4857 | * ClearPin                                                          |   0x07 |
4858 | * ClearRfid                                                         |   0x18 |
4859 | * ClearWeekdaySchedule                                              |   0x0D |
4860 | * ClearYeardaySchedule                                              |   0x10 |
4861 | * GetHolidaySchedule                                                |   0x12 |
4862 | * GetLogRecord                                                      |   0x04 |
4863 | * GetPin                                                            |   0x06 |
4864 | * GetRfid                                                           |   0x17 |
4865 | * GetUserType                                                       |   0x15 |
4866 | * GetWeekdaySchedule                                                |   0x0C |
4867 | * GetYeardaySchedule                                                |   0x0F |
4868 | * LockDoor                                                          |   0x00 |
4869 | * SetHolidaySchedule                                                |   0x11 |
4870 | * SetPin                                                            |   0x05 |
4871 | * SetRfid                                                           |   0x16 |
4872 | * SetUserType                                                       |   0x14 |
4873 | * SetWeekdaySchedule                                                |   0x0B |
4874 | * SetYeardaySchedule                                                |   0x0E |
4875 | * UnlockDoor                                                        |   0x01 |
4876 | * UnlockWithTimeout                                                 |   0x03 |
4877 |------------------------------------------------------------------------------|
4878 | Attributes:                                                         |        |
4879 | * LockState                                                         | 0x0000 |
4880 | * LockType                                                          | 0x0001 |
4881 | * ActuatorEnabled                                                   | 0x0002 |
4882 | * ClusterRevision                                                   | 0xFFFD |
4883 \*----------------------------------------------------------------------------*/
4884
4885 /*
4886  * Command ClearAllPins
4887  */
4888 class DoorLockClearAllPins : public ModelCommand
4889 {
4890 public:
4891     DoorLockClearAllPins() : ModelCommand("clear-all-pins") { ModelCommand::AddArguments(); }
4892     ~DoorLockClearAllPins()
4893     {
4894         delete onSuccessCallback;
4895         delete onFailureCallback;
4896     }
4897
4898     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
4899     {
4900         ChipLogProgress(chipTool, "Sending cluster (0x0101) command (0x08) on endpoint %" PRIu16, endpointId);
4901
4902         chip::Controller::DoorLockCluster cluster;
4903         cluster.Associate(device, endpointId);
4904         return cluster.ClearAllPins(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
4905     }
4906
4907 private:
4908     chip::Callback::Callback<DoorLockClusterClearAllPinsResponseCallback> * onSuccessCallback =
4909         new chip::Callback::Callback<DoorLockClusterClearAllPinsResponseCallback>(OnDoorLockClusterClearAllPinsResponse, this);
4910     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
4911         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
4912 };
4913
4914 /*
4915  * Command ClearAllRfids
4916  */
4917 class DoorLockClearAllRfids : public ModelCommand
4918 {
4919 public:
4920     DoorLockClearAllRfids() : ModelCommand("clear-all-rfids") { ModelCommand::AddArguments(); }
4921     ~DoorLockClearAllRfids()
4922     {
4923         delete onSuccessCallback;
4924         delete onFailureCallback;
4925     }
4926
4927     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
4928     {
4929         ChipLogProgress(chipTool, "Sending cluster (0x0101) command (0x19) on endpoint %" PRIu16, endpointId);
4930
4931         chip::Controller::DoorLockCluster cluster;
4932         cluster.Associate(device, endpointId);
4933         return cluster.ClearAllRfids(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
4934     }
4935
4936 private:
4937     chip::Callback::Callback<DoorLockClusterClearAllRfidsResponseCallback> * onSuccessCallback =
4938         new chip::Callback::Callback<DoorLockClusterClearAllRfidsResponseCallback>(OnDoorLockClusterClearAllRfidsResponse, this);
4939     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
4940         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
4941 };
4942
4943 /*
4944  * Command ClearHolidaySchedule
4945  */
4946 class DoorLockClearHolidaySchedule : public ModelCommand
4947 {
4948 public:
4949     DoorLockClearHolidaySchedule() : ModelCommand("clear-holiday-schedule")
4950     {
4951         AddArgument("scheduleId", 0, UINT8_MAX, &mScheduleId);
4952         ModelCommand::AddArguments();
4953     }
4954     ~DoorLockClearHolidaySchedule()
4955     {
4956         delete onSuccessCallback;
4957         delete onFailureCallback;
4958     }
4959
4960     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
4961     {
4962         ChipLogProgress(chipTool, "Sending cluster (0x0101) command (0x13) on endpoint %" PRIu16, endpointId);
4963
4964         chip::Controller::DoorLockCluster cluster;
4965         cluster.Associate(device, endpointId);
4966         return cluster.ClearHolidaySchedule(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mScheduleId);
4967     }
4968
4969 private:
4970     chip::Callback::Callback<DoorLockClusterClearHolidayScheduleResponseCallback> * onSuccessCallback =
4971         new chip::Callback::Callback<DoorLockClusterClearHolidayScheduleResponseCallback>(
4972             OnDoorLockClusterClearHolidayScheduleResponse, this);
4973     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
4974         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
4975     uint8_t mScheduleId;
4976 };
4977
4978 /*
4979  * Command ClearPin
4980  */
4981 class DoorLockClearPin : public ModelCommand
4982 {
4983 public:
4984     DoorLockClearPin() : ModelCommand("clear-pin")
4985     {
4986         AddArgument("userId", 0, UINT16_MAX, &mUserId);
4987         ModelCommand::AddArguments();
4988     }
4989     ~DoorLockClearPin()
4990     {
4991         delete onSuccessCallback;
4992         delete onFailureCallback;
4993     }
4994
4995     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
4996     {
4997         ChipLogProgress(chipTool, "Sending cluster (0x0101) command (0x07) on endpoint %" PRIu16, endpointId);
4998
4999         chip::Controller::DoorLockCluster cluster;
5000         cluster.Associate(device, endpointId);
5001         return cluster.ClearPin(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mUserId);
5002     }
5003
5004 private:
5005     chip::Callback::Callback<DoorLockClusterClearPinResponseCallback> * onSuccessCallback =
5006         new chip::Callback::Callback<DoorLockClusterClearPinResponseCallback>(OnDoorLockClusterClearPinResponse, this);
5007     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
5008         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
5009     uint16_t mUserId;
5010 };
5011
5012 /*
5013  * Command ClearRfid
5014  */
5015 class DoorLockClearRfid : public ModelCommand
5016 {
5017 public:
5018     DoorLockClearRfid() : ModelCommand("clear-rfid")
5019     {
5020         AddArgument("userId", 0, UINT16_MAX, &mUserId);
5021         ModelCommand::AddArguments();
5022     }
5023     ~DoorLockClearRfid()
5024     {
5025         delete onSuccessCallback;
5026         delete onFailureCallback;
5027     }
5028
5029     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
5030     {
5031         ChipLogProgress(chipTool, "Sending cluster (0x0101) command (0x18) on endpoint %" PRIu16, endpointId);
5032
5033         chip::Controller::DoorLockCluster cluster;
5034         cluster.Associate(device, endpointId);
5035         return cluster.ClearRfid(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mUserId);
5036     }
5037
5038 private:
5039     chip::Callback::Callback<DoorLockClusterClearRfidResponseCallback> * onSuccessCallback =
5040         new chip::Callback::Callback<DoorLockClusterClearRfidResponseCallback>(OnDoorLockClusterClearRfidResponse, this);
5041     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
5042         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
5043     uint16_t mUserId;
5044 };
5045
5046 /*
5047  * Command ClearWeekdaySchedule
5048  */
5049 class DoorLockClearWeekdaySchedule : public ModelCommand
5050 {
5051 public:
5052     DoorLockClearWeekdaySchedule() : ModelCommand("clear-weekday-schedule")
5053     {
5054         AddArgument("scheduleId", 0, UINT8_MAX, &mScheduleId);
5055         AddArgument("userId", 0, UINT16_MAX, &mUserId);
5056         ModelCommand::AddArguments();
5057     }
5058     ~DoorLockClearWeekdaySchedule()
5059     {
5060         delete onSuccessCallback;
5061         delete onFailureCallback;
5062     }
5063
5064     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
5065     {
5066         ChipLogProgress(chipTool, "Sending cluster (0x0101) command (0x0D) on endpoint %" PRIu16, endpointId);
5067
5068         chip::Controller::DoorLockCluster cluster;
5069         cluster.Associate(device, endpointId);
5070         return cluster.ClearWeekdaySchedule(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mScheduleId, mUserId);
5071     }
5072
5073 private:
5074     chip::Callback::Callback<DoorLockClusterClearWeekdayScheduleResponseCallback> * onSuccessCallback =
5075         new chip::Callback::Callback<DoorLockClusterClearWeekdayScheduleResponseCallback>(
5076             OnDoorLockClusterClearWeekdayScheduleResponse, this);
5077     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
5078         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
5079     uint8_t mScheduleId;
5080     uint16_t mUserId;
5081 };
5082
5083 /*
5084  * Command ClearYeardaySchedule
5085  */
5086 class DoorLockClearYeardaySchedule : public ModelCommand
5087 {
5088 public:
5089     DoorLockClearYeardaySchedule() : ModelCommand("clear-yearday-schedule")
5090     {
5091         AddArgument("scheduleId", 0, UINT8_MAX, &mScheduleId);
5092         AddArgument("userId", 0, UINT16_MAX, &mUserId);
5093         ModelCommand::AddArguments();
5094     }
5095     ~DoorLockClearYeardaySchedule()
5096     {
5097         delete onSuccessCallback;
5098         delete onFailureCallback;
5099     }
5100
5101     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
5102     {
5103         ChipLogProgress(chipTool, "Sending cluster (0x0101) command (0x10) on endpoint %" PRIu16, endpointId);
5104
5105         chip::Controller::DoorLockCluster cluster;
5106         cluster.Associate(device, endpointId);
5107         return cluster.ClearYeardaySchedule(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mScheduleId, mUserId);
5108     }
5109
5110 private:
5111     chip::Callback::Callback<DoorLockClusterClearYeardayScheduleResponseCallback> * onSuccessCallback =
5112         new chip::Callback::Callback<DoorLockClusterClearYeardayScheduleResponseCallback>(
5113             OnDoorLockClusterClearYeardayScheduleResponse, this);
5114     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
5115         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
5116     uint8_t mScheduleId;
5117     uint16_t mUserId;
5118 };
5119
5120 /*
5121  * Command GetHolidaySchedule
5122  */
5123 class DoorLockGetHolidaySchedule : public ModelCommand
5124 {
5125 public:
5126     DoorLockGetHolidaySchedule() : ModelCommand("get-holiday-schedule")
5127     {
5128         AddArgument("scheduleId", 0, UINT8_MAX, &mScheduleId);
5129         ModelCommand::AddArguments();
5130     }
5131     ~DoorLockGetHolidaySchedule()
5132     {
5133         delete onSuccessCallback;
5134         delete onFailureCallback;
5135     }
5136
5137     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
5138     {
5139         ChipLogProgress(chipTool, "Sending cluster (0x0101) command (0x12) on endpoint %" PRIu16, endpointId);
5140
5141         chip::Controller::DoorLockCluster cluster;
5142         cluster.Associate(device, endpointId);
5143         return cluster.GetHolidaySchedule(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mScheduleId);
5144     }
5145
5146 private:
5147     chip::Callback::Callback<DoorLockClusterGetHolidayScheduleResponseCallback> * onSuccessCallback =
5148         new chip::Callback::Callback<DoorLockClusterGetHolidayScheduleResponseCallback>(OnDoorLockClusterGetHolidayScheduleResponse,
5149                                                                                         this);
5150     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
5151         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
5152     uint8_t mScheduleId;
5153 };
5154
5155 /*
5156  * Command GetLogRecord
5157  */
5158 class DoorLockGetLogRecord : public ModelCommand
5159 {
5160 public:
5161     DoorLockGetLogRecord() : ModelCommand("get-log-record")
5162     {
5163         AddArgument("logIndex", 0, UINT16_MAX, &mLogIndex);
5164         ModelCommand::AddArguments();
5165     }
5166     ~DoorLockGetLogRecord()
5167     {
5168         delete onSuccessCallback;
5169         delete onFailureCallback;
5170     }
5171
5172     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
5173     {
5174         ChipLogProgress(chipTool, "Sending cluster (0x0101) command (0x04) on endpoint %" PRIu16, endpointId);
5175
5176         chip::Controller::DoorLockCluster cluster;
5177         cluster.Associate(device, endpointId);
5178         return cluster.GetLogRecord(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mLogIndex);
5179     }
5180
5181 private:
5182     chip::Callback::Callback<DoorLockClusterGetLogRecordResponseCallback> * onSuccessCallback =
5183         new chip::Callback::Callback<DoorLockClusterGetLogRecordResponseCallback>(OnDoorLockClusterGetLogRecordResponse, this);
5184     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
5185         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
5186     uint16_t mLogIndex;
5187 };
5188
5189 /*
5190  * Command GetPin
5191  */
5192 class DoorLockGetPin : public ModelCommand
5193 {
5194 public:
5195     DoorLockGetPin() : ModelCommand("get-pin")
5196     {
5197         AddArgument("userId", 0, UINT16_MAX, &mUserId);
5198         ModelCommand::AddArguments();
5199     }
5200     ~DoorLockGetPin()
5201     {
5202         delete onSuccessCallback;
5203         delete onFailureCallback;
5204     }
5205
5206     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
5207     {
5208         ChipLogProgress(chipTool, "Sending cluster (0x0101) command (0x06) on endpoint %" PRIu16, endpointId);
5209
5210         chip::Controller::DoorLockCluster cluster;
5211         cluster.Associate(device, endpointId);
5212         return cluster.GetPin(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mUserId);
5213     }
5214
5215 private:
5216     chip::Callback::Callback<DoorLockClusterGetPinResponseCallback> * onSuccessCallback =
5217         new chip::Callback::Callback<DoorLockClusterGetPinResponseCallback>(OnDoorLockClusterGetPinResponse, this);
5218     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
5219         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
5220     uint16_t mUserId;
5221 };
5222
5223 /*
5224  * Command GetRfid
5225  */
5226 class DoorLockGetRfid : public ModelCommand
5227 {
5228 public:
5229     DoorLockGetRfid() : ModelCommand("get-rfid")
5230     {
5231         AddArgument("userId", 0, UINT16_MAX, &mUserId);
5232         ModelCommand::AddArguments();
5233     }
5234     ~DoorLockGetRfid()
5235     {
5236         delete onSuccessCallback;
5237         delete onFailureCallback;
5238     }
5239
5240     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
5241     {
5242         ChipLogProgress(chipTool, "Sending cluster (0x0101) command (0x17) on endpoint %" PRIu16, endpointId);
5243
5244         chip::Controller::DoorLockCluster cluster;
5245         cluster.Associate(device, endpointId);
5246         return cluster.GetRfid(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mUserId);
5247     }
5248
5249 private:
5250     chip::Callback::Callback<DoorLockClusterGetRfidResponseCallback> * onSuccessCallback =
5251         new chip::Callback::Callback<DoorLockClusterGetRfidResponseCallback>(OnDoorLockClusterGetRfidResponse, this);
5252     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
5253         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
5254     uint16_t mUserId;
5255 };
5256
5257 /*
5258  * Command GetUserType
5259  */
5260 class DoorLockGetUserType : public ModelCommand
5261 {
5262 public:
5263     DoorLockGetUserType() : ModelCommand("get-user-type")
5264     {
5265         AddArgument("userId", 0, UINT16_MAX, &mUserId);
5266         ModelCommand::AddArguments();
5267     }
5268     ~DoorLockGetUserType()
5269     {
5270         delete onSuccessCallback;
5271         delete onFailureCallback;
5272     }
5273
5274     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
5275     {
5276         ChipLogProgress(chipTool, "Sending cluster (0x0101) command (0x15) on endpoint %" PRIu16, endpointId);
5277
5278         chip::Controller::DoorLockCluster cluster;
5279         cluster.Associate(device, endpointId);
5280         return cluster.GetUserType(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mUserId);
5281     }
5282
5283 private:
5284     chip::Callback::Callback<DoorLockClusterGetUserTypeResponseCallback> * onSuccessCallback =
5285         new chip::Callback::Callback<DoorLockClusterGetUserTypeResponseCallback>(OnDoorLockClusterGetUserTypeResponse, this);
5286     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
5287         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
5288     uint16_t mUserId;
5289 };
5290
5291 /*
5292  * Command GetWeekdaySchedule
5293  */
5294 class DoorLockGetWeekdaySchedule : public ModelCommand
5295 {
5296 public:
5297     DoorLockGetWeekdaySchedule() : ModelCommand("get-weekday-schedule")
5298     {
5299         AddArgument("scheduleId", 0, UINT8_MAX, &mScheduleId);
5300         AddArgument("userId", 0, UINT16_MAX, &mUserId);
5301         ModelCommand::AddArguments();
5302     }
5303     ~DoorLockGetWeekdaySchedule()
5304     {
5305         delete onSuccessCallback;
5306         delete onFailureCallback;
5307     }
5308
5309     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
5310     {
5311         ChipLogProgress(chipTool, "Sending cluster (0x0101) command (0x0C) on endpoint %" PRIu16, endpointId);
5312
5313         chip::Controller::DoorLockCluster cluster;
5314         cluster.Associate(device, endpointId);
5315         return cluster.GetWeekdaySchedule(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mScheduleId, mUserId);
5316     }
5317
5318 private:
5319     chip::Callback::Callback<DoorLockClusterGetWeekdayScheduleResponseCallback> * onSuccessCallback =
5320         new chip::Callback::Callback<DoorLockClusterGetWeekdayScheduleResponseCallback>(OnDoorLockClusterGetWeekdayScheduleResponse,
5321                                                                                         this);
5322     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
5323         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
5324     uint8_t mScheduleId;
5325     uint16_t mUserId;
5326 };
5327
5328 /*
5329  * Command GetYeardaySchedule
5330  */
5331 class DoorLockGetYeardaySchedule : public ModelCommand
5332 {
5333 public:
5334     DoorLockGetYeardaySchedule() : ModelCommand("get-yearday-schedule")
5335     {
5336         AddArgument("scheduleId", 0, UINT8_MAX, &mScheduleId);
5337         AddArgument("userId", 0, UINT16_MAX, &mUserId);
5338         ModelCommand::AddArguments();
5339     }
5340     ~DoorLockGetYeardaySchedule()
5341     {
5342         delete onSuccessCallback;
5343         delete onFailureCallback;
5344     }
5345
5346     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
5347     {
5348         ChipLogProgress(chipTool, "Sending cluster (0x0101) command (0x0F) on endpoint %" PRIu16, endpointId);
5349
5350         chip::Controller::DoorLockCluster cluster;
5351         cluster.Associate(device, endpointId);
5352         return cluster.GetYeardaySchedule(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mScheduleId, mUserId);
5353     }
5354
5355 private:
5356     chip::Callback::Callback<DoorLockClusterGetYeardayScheduleResponseCallback> * onSuccessCallback =
5357         new chip::Callback::Callback<DoorLockClusterGetYeardayScheduleResponseCallback>(OnDoorLockClusterGetYeardayScheduleResponse,
5358                                                                                         this);
5359     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
5360         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
5361     uint8_t mScheduleId;
5362     uint16_t mUserId;
5363 };
5364
5365 /*
5366  * Command LockDoor
5367  */
5368 class DoorLockLockDoor : public ModelCommand
5369 {
5370 public:
5371     DoorLockLockDoor() : ModelCommand("lock-door")
5372     {
5373         AddArgument("pin", &mPin);
5374         ModelCommand::AddArguments();
5375     }
5376     ~DoorLockLockDoor()
5377     {
5378         delete onSuccessCallback;
5379         delete onFailureCallback;
5380     }
5381
5382     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
5383     {
5384         ChipLogProgress(chipTool, "Sending cluster (0x0101) command (0x00) on endpoint %" PRIu16, endpointId);
5385
5386         chip::Controller::DoorLockCluster cluster;
5387         cluster.Associate(device, endpointId);
5388         return cluster.LockDoor(onSuccessCallback->Cancel(), onFailureCallback->Cancel(),
5389                                 chip::ByteSpan(chip::Uint8::from_char(mPin), strlen(mPin)));
5390     }
5391
5392 private:
5393     chip::Callback::Callback<DoorLockClusterLockDoorResponseCallback> * onSuccessCallback =
5394         new chip::Callback::Callback<DoorLockClusterLockDoorResponseCallback>(OnDoorLockClusterLockDoorResponse, this);
5395     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
5396         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
5397     char * mPin;
5398 };
5399
5400 /*
5401  * Command SetHolidaySchedule
5402  */
5403 class DoorLockSetHolidaySchedule : public ModelCommand
5404 {
5405 public:
5406     DoorLockSetHolidaySchedule() : ModelCommand("set-holiday-schedule")
5407     {
5408         AddArgument("scheduleId", 0, UINT8_MAX, &mScheduleId);
5409         AddArgument("localStartTime", 0, UINT32_MAX, &mLocalStartTime);
5410         AddArgument("localEndTime", 0, UINT32_MAX, &mLocalEndTime);
5411         AddArgument("operatingModeDuringHoliday", 0, UINT8_MAX, &mOperatingModeDuringHoliday);
5412         ModelCommand::AddArguments();
5413     }
5414     ~DoorLockSetHolidaySchedule()
5415     {
5416         delete onSuccessCallback;
5417         delete onFailureCallback;
5418     }
5419
5420     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
5421     {
5422         ChipLogProgress(chipTool, "Sending cluster (0x0101) command (0x11) on endpoint %" PRIu16, endpointId);
5423
5424         chip::Controller::DoorLockCluster cluster;
5425         cluster.Associate(device, endpointId);
5426         return cluster.SetHolidaySchedule(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mScheduleId, mLocalStartTime,
5427                                           mLocalEndTime, mOperatingModeDuringHoliday);
5428     }
5429
5430 private:
5431     chip::Callback::Callback<DoorLockClusterSetHolidayScheduleResponseCallback> * onSuccessCallback =
5432         new chip::Callback::Callback<DoorLockClusterSetHolidayScheduleResponseCallback>(OnDoorLockClusterSetHolidayScheduleResponse,
5433                                                                                         this);
5434     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
5435         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
5436     uint8_t mScheduleId;
5437     uint32_t mLocalStartTime;
5438     uint32_t mLocalEndTime;
5439     uint8_t mOperatingModeDuringHoliday;
5440 };
5441
5442 /*
5443  * Command SetPin
5444  */
5445 class DoorLockSetPin : public ModelCommand
5446 {
5447 public:
5448     DoorLockSetPin() : ModelCommand("set-pin")
5449     {
5450         AddArgument("userId", 0, UINT16_MAX, &mUserId);
5451         AddArgument("userStatus", 0, UINT8_MAX, &mUserStatus);
5452         AddArgument("userType", 0, UINT8_MAX, &mUserType);
5453         AddArgument("pin", &mPin);
5454         ModelCommand::AddArguments();
5455     }
5456     ~DoorLockSetPin()
5457     {
5458         delete onSuccessCallback;
5459         delete onFailureCallback;
5460     }
5461
5462     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
5463     {
5464         ChipLogProgress(chipTool, "Sending cluster (0x0101) command (0x05) on endpoint %" PRIu16, endpointId);
5465
5466         chip::Controller::DoorLockCluster cluster;
5467         cluster.Associate(device, endpointId);
5468         return cluster.SetPin(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mUserId, mUserStatus, mUserType,
5469                               chip::ByteSpan(chip::Uint8::from_char(mPin), strlen(mPin)));
5470     }
5471
5472 private:
5473     chip::Callback::Callback<DoorLockClusterSetPinResponseCallback> * onSuccessCallback =
5474         new chip::Callback::Callback<DoorLockClusterSetPinResponseCallback>(OnDoorLockClusterSetPinResponse, this);
5475     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
5476         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
5477     uint16_t mUserId;
5478     uint8_t mUserStatus;
5479     uint8_t mUserType;
5480     char * mPin;
5481 };
5482
5483 /*
5484  * Command SetRfid
5485  */
5486 class DoorLockSetRfid : public ModelCommand
5487 {
5488 public:
5489     DoorLockSetRfid() : ModelCommand("set-rfid")
5490     {
5491         AddArgument("userId", 0, UINT16_MAX, &mUserId);
5492         AddArgument("userStatus", 0, UINT8_MAX, &mUserStatus);
5493         AddArgument("userType", 0, UINT8_MAX, &mUserType);
5494         AddArgument("id", &mId);
5495         ModelCommand::AddArguments();
5496     }
5497     ~DoorLockSetRfid()
5498     {
5499         delete onSuccessCallback;
5500         delete onFailureCallback;
5501     }
5502
5503     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
5504     {
5505         ChipLogProgress(chipTool, "Sending cluster (0x0101) command (0x16) on endpoint %" PRIu16, endpointId);
5506
5507         chip::Controller::DoorLockCluster cluster;
5508         cluster.Associate(device, endpointId);
5509         return cluster.SetRfid(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mUserId, mUserStatus, mUserType,
5510                                chip::ByteSpan(chip::Uint8::from_char(mId), strlen(mId)));
5511     }
5512
5513 private:
5514     chip::Callback::Callback<DoorLockClusterSetRfidResponseCallback> * onSuccessCallback =
5515         new chip::Callback::Callback<DoorLockClusterSetRfidResponseCallback>(OnDoorLockClusterSetRfidResponse, this);
5516     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
5517         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
5518     uint16_t mUserId;
5519     uint8_t mUserStatus;
5520     uint8_t mUserType;
5521     char * mId;
5522 };
5523
5524 /*
5525  * Command SetUserType
5526  */
5527 class DoorLockSetUserType : public ModelCommand
5528 {
5529 public:
5530     DoorLockSetUserType() : ModelCommand("set-user-type")
5531     {
5532         AddArgument("userId", 0, UINT16_MAX, &mUserId);
5533         AddArgument("userType", 0, UINT8_MAX, &mUserType);
5534         ModelCommand::AddArguments();
5535     }
5536     ~DoorLockSetUserType()
5537     {
5538         delete onSuccessCallback;
5539         delete onFailureCallback;
5540     }
5541
5542     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
5543     {
5544         ChipLogProgress(chipTool, "Sending cluster (0x0101) command (0x14) on endpoint %" PRIu16, endpointId);
5545
5546         chip::Controller::DoorLockCluster cluster;
5547         cluster.Associate(device, endpointId);
5548         return cluster.SetUserType(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mUserId, mUserType);
5549     }
5550
5551 private:
5552     chip::Callback::Callback<DoorLockClusterSetUserTypeResponseCallback> * onSuccessCallback =
5553         new chip::Callback::Callback<DoorLockClusterSetUserTypeResponseCallback>(OnDoorLockClusterSetUserTypeResponse, this);
5554     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
5555         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
5556     uint16_t mUserId;
5557     uint8_t mUserType;
5558 };
5559
5560 /*
5561  * Command SetWeekdaySchedule
5562  */
5563 class DoorLockSetWeekdaySchedule : public ModelCommand
5564 {
5565 public:
5566     DoorLockSetWeekdaySchedule() : ModelCommand("set-weekday-schedule")
5567     {
5568         AddArgument("scheduleId", 0, UINT8_MAX, &mScheduleId);
5569         AddArgument("userId", 0, UINT16_MAX, &mUserId);
5570         AddArgument("daysMask", 0, UINT8_MAX, &mDaysMask);
5571         AddArgument("startHour", 0, UINT8_MAX, &mStartHour);
5572         AddArgument("startMinute", 0, UINT8_MAX, &mStartMinute);
5573         AddArgument("endHour", 0, UINT8_MAX, &mEndHour);
5574         AddArgument("endMinute", 0, UINT8_MAX, &mEndMinute);
5575         ModelCommand::AddArguments();
5576     }
5577     ~DoorLockSetWeekdaySchedule()
5578     {
5579         delete onSuccessCallback;
5580         delete onFailureCallback;
5581     }
5582
5583     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
5584     {
5585         ChipLogProgress(chipTool, "Sending cluster (0x0101) command (0x0B) on endpoint %" PRIu16, endpointId);
5586
5587         chip::Controller::DoorLockCluster cluster;
5588         cluster.Associate(device, endpointId);
5589         return cluster.SetWeekdaySchedule(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mScheduleId, mUserId, mDaysMask,
5590                                           mStartHour, mStartMinute, mEndHour, mEndMinute);
5591     }
5592
5593 private:
5594     chip::Callback::Callback<DoorLockClusterSetWeekdayScheduleResponseCallback> * onSuccessCallback =
5595         new chip::Callback::Callback<DoorLockClusterSetWeekdayScheduleResponseCallback>(OnDoorLockClusterSetWeekdayScheduleResponse,
5596                                                                                         this);
5597     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
5598         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
5599     uint8_t mScheduleId;
5600     uint16_t mUserId;
5601     uint8_t mDaysMask;
5602     uint8_t mStartHour;
5603     uint8_t mStartMinute;
5604     uint8_t mEndHour;
5605     uint8_t mEndMinute;
5606 };
5607
5608 /*
5609  * Command SetYeardaySchedule
5610  */
5611 class DoorLockSetYeardaySchedule : public ModelCommand
5612 {
5613 public:
5614     DoorLockSetYeardaySchedule() : ModelCommand("set-yearday-schedule")
5615     {
5616         AddArgument("scheduleId", 0, UINT8_MAX, &mScheduleId);
5617         AddArgument("userId", 0, UINT16_MAX, &mUserId);
5618         AddArgument("localStartTime", 0, UINT32_MAX, &mLocalStartTime);
5619         AddArgument("localEndTime", 0, UINT32_MAX, &mLocalEndTime);
5620         ModelCommand::AddArguments();
5621     }
5622     ~DoorLockSetYeardaySchedule()
5623     {
5624         delete onSuccessCallback;
5625         delete onFailureCallback;
5626     }
5627
5628     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
5629     {
5630         ChipLogProgress(chipTool, "Sending cluster (0x0101) command (0x0E) on endpoint %" PRIu16, endpointId);
5631
5632         chip::Controller::DoorLockCluster cluster;
5633         cluster.Associate(device, endpointId);
5634         return cluster.SetYeardaySchedule(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mScheduleId, mUserId,
5635                                           mLocalStartTime, mLocalEndTime);
5636     }
5637
5638 private:
5639     chip::Callback::Callback<DoorLockClusterSetYeardayScheduleResponseCallback> * onSuccessCallback =
5640         new chip::Callback::Callback<DoorLockClusterSetYeardayScheduleResponseCallback>(OnDoorLockClusterSetYeardayScheduleResponse,
5641                                                                                         this);
5642     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
5643         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
5644     uint8_t mScheduleId;
5645     uint16_t mUserId;
5646     uint32_t mLocalStartTime;
5647     uint32_t mLocalEndTime;
5648 };
5649
5650 /*
5651  * Command UnlockDoor
5652  */
5653 class DoorLockUnlockDoor : public ModelCommand
5654 {
5655 public:
5656     DoorLockUnlockDoor() : ModelCommand("unlock-door")
5657     {
5658         AddArgument("pin", &mPin);
5659         ModelCommand::AddArguments();
5660     }
5661     ~DoorLockUnlockDoor()
5662     {
5663         delete onSuccessCallback;
5664         delete onFailureCallback;
5665     }
5666
5667     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
5668     {
5669         ChipLogProgress(chipTool, "Sending cluster (0x0101) command (0x01) on endpoint %" PRIu16, endpointId);
5670
5671         chip::Controller::DoorLockCluster cluster;
5672         cluster.Associate(device, endpointId);
5673         return cluster.UnlockDoor(onSuccessCallback->Cancel(), onFailureCallback->Cancel(),
5674                                   chip::ByteSpan(chip::Uint8::from_char(mPin), strlen(mPin)));
5675     }
5676
5677 private:
5678     chip::Callback::Callback<DoorLockClusterUnlockDoorResponseCallback> * onSuccessCallback =
5679         new chip::Callback::Callback<DoorLockClusterUnlockDoorResponseCallback>(OnDoorLockClusterUnlockDoorResponse, this);
5680     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
5681         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
5682     char * mPin;
5683 };
5684
5685 /*
5686  * Command UnlockWithTimeout
5687  */
5688 class DoorLockUnlockWithTimeout : public ModelCommand
5689 {
5690 public:
5691     DoorLockUnlockWithTimeout() : ModelCommand("unlock-with-timeout")
5692     {
5693         AddArgument("timeoutInSeconds", 0, UINT16_MAX, &mTimeoutInSeconds);
5694         AddArgument("pin", &mPin);
5695         ModelCommand::AddArguments();
5696     }
5697     ~DoorLockUnlockWithTimeout()
5698     {
5699         delete onSuccessCallback;
5700         delete onFailureCallback;
5701     }
5702
5703     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
5704     {
5705         ChipLogProgress(chipTool, "Sending cluster (0x0101) command (0x03) on endpoint %" PRIu16, endpointId);
5706
5707         chip::Controller::DoorLockCluster cluster;
5708         cluster.Associate(device, endpointId);
5709         return cluster.UnlockWithTimeout(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mTimeoutInSeconds,
5710                                          chip::ByteSpan(chip::Uint8::from_char(mPin), strlen(mPin)));
5711     }
5712
5713 private:
5714     chip::Callback::Callback<DoorLockClusterUnlockWithTimeoutResponseCallback> * onSuccessCallback =
5715         new chip::Callback::Callback<DoorLockClusterUnlockWithTimeoutResponseCallback>(OnDoorLockClusterUnlockWithTimeoutResponse,
5716                                                                                        this);
5717     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
5718         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
5719     uint16_t mTimeoutInSeconds;
5720     char * mPin;
5721 };
5722
5723 /*
5724  * Discover Attributes
5725  */
5726 class DiscoverDoorLockAttributes : public ModelCommand
5727 {
5728 public:
5729     DiscoverDoorLockAttributes() : ModelCommand("discover") { ModelCommand::AddArguments(); }
5730
5731     ~DiscoverDoorLockAttributes()
5732     {
5733         delete onSuccessCallback;
5734         delete onFailureCallback;
5735     }
5736
5737     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
5738     {
5739         ChipLogProgress(chipTool, "Sending cluster (0x0000) command (0x0C) on endpoint %" PRIu16, endpointId);
5740
5741         chip::Controller::DoorLockCluster cluster;
5742         cluster.Associate(device, endpointId);
5743         return cluster.DiscoverAttributes(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
5744     }
5745
5746 private:
5747     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
5748         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
5749     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
5750         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
5751 };
5752
5753 /*
5754  * Attribute LockState
5755  */
5756 class ReadDoorLockLockState : public ModelCommand
5757 {
5758 public:
5759     ReadDoorLockLockState() : ModelCommand("read")
5760     {
5761         AddArgument("attr-name", "lock-state");
5762         ModelCommand::AddArguments();
5763     }
5764
5765     ~ReadDoorLockLockState()
5766     {
5767         delete onSuccessCallback;
5768         delete onFailureCallback;
5769     }
5770
5771     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
5772     {
5773         ChipLogProgress(chipTool, "Sending cluster (0x0101) command (0x00) on endpoint %" PRIu16, endpointId);
5774
5775         chip::Controller::DoorLockCluster cluster;
5776         cluster.Associate(device, endpointId);
5777         return cluster.ReadAttributeLockState(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
5778     }
5779
5780 private:
5781     chip::Callback::Callback<Int8uAttributeCallback> * onSuccessCallback =
5782         new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
5783     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
5784         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
5785 };
5786
5787 class ReportDoorLockLockState : public ModelCommand
5788 {
5789 public:
5790     ReportDoorLockLockState() : ModelCommand("report")
5791     {
5792         AddArgument("attr-name", "lock-state");
5793         AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval);
5794         AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval);
5795         ModelCommand::AddArguments();
5796     }
5797
5798     ~ReportDoorLockLockState()
5799     {
5800         delete onSuccessCallback;
5801         delete onFailureCallback;
5802         delete onReportCallback;
5803     }
5804
5805     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
5806     {
5807         ChipLogProgress(chipTool, "Sending cluster (0x0101) command (0x06) on endpoint %" PRIu16, endpointId);
5808
5809         chip::Controller::DoorLockCluster cluster;
5810         cluster.Associate(device, endpointId);
5811
5812         CHIP_ERROR err = cluster.ReportAttributeLockState(onReportCallback->Cancel());
5813         if (err != CHIP_NO_ERROR)
5814         {
5815             return err;
5816         }
5817
5818         return cluster.ConfigureAttributeLockState(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval,
5819                                                    mMaxInterval);
5820     }
5821
5822 private:
5823     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
5824         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
5825     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
5826         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
5827     chip::Callback::Callback<Int8uAttributeCallback> * onReportCallback =
5828         new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
5829     uint16_t mMinInterval;
5830     uint16_t mMaxInterval;
5831 };
5832
5833 /*
5834  * Attribute LockType
5835  */
5836 class ReadDoorLockLockType : public ModelCommand
5837 {
5838 public:
5839     ReadDoorLockLockType() : ModelCommand("read")
5840     {
5841         AddArgument("attr-name", "lock-type");
5842         ModelCommand::AddArguments();
5843     }
5844
5845     ~ReadDoorLockLockType()
5846     {
5847         delete onSuccessCallback;
5848         delete onFailureCallback;
5849     }
5850
5851     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
5852     {
5853         ChipLogProgress(chipTool, "Sending cluster (0x0101) command (0x00) on endpoint %" PRIu16, endpointId);
5854
5855         chip::Controller::DoorLockCluster cluster;
5856         cluster.Associate(device, endpointId);
5857         return cluster.ReadAttributeLockType(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
5858     }
5859
5860 private:
5861     chip::Callback::Callback<Int8uAttributeCallback> * onSuccessCallback =
5862         new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
5863     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
5864         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
5865 };
5866
5867 /*
5868  * Attribute ActuatorEnabled
5869  */
5870 class ReadDoorLockActuatorEnabled : public ModelCommand
5871 {
5872 public:
5873     ReadDoorLockActuatorEnabled() : ModelCommand("read")
5874     {
5875         AddArgument("attr-name", "actuator-enabled");
5876         ModelCommand::AddArguments();
5877     }
5878
5879     ~ReadDoorLockActuatorEnabled()
5880     {
5881         delete onSuccessCallback;
5882         delete onFailureCallback;
5883     }
5884
5885     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
5886     {
5887         ChipLogProgress(chipTool, "Sending cluster (0x0101) command (0x00) on endpoint %" PRIu16, endpointId);
5888
5889         chip::Controller::DoorLockCluster cluster;
5890         cluster.Associate(device, endpointId);
5891         return cluster.ReadAttributeActuatorEnabled(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
5892     }
5893
5894 private:
5895     chip::Callback::Callback<BooleanAttributeCallback> * onSuccessCallback =
5896         new chip::Callback::Callback<BooleanAttributeCallback>(OnBooleanAttributeResponse, this);
5897     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
5898         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
5899 };
5900
5901 /*
5902  * Attribute ClusterRevision
5903  */
5904 class ReadDoorLockClusterRevision : public ModelCommand
5905 {
5906 public:
5907     ReadDoorLockClusterRevision() : ModelCommand("read")
5908     {
5909         AddArgument("attr-name", "cluster-revision");
5910         ModelCommand::AddArguments();
5911     }
5912
5913     ~ReadDoorLockClusterRevision()
5914     {
5915         delete onSuccessCallback;
5916         delete onFailureCallback;
5917     }
5918
5919     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
5920     {
5921         ChipLogProgress(chipTool, "Sending cluster (0x0101) command (0x00) on endpoint %" PRIu16, endpointId);
5922
5923         chip::Controller::DoorLockCluster cluster;
5924         cluster.Associate(device, endpointId);
5925         return cluster.ReadAttributeClusterRevision(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
5926     }
5927
5928 private:
5929     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
5930         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
5931     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
5932         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
5933 };
5934
5935 /*----------------------------------------------------------------------------*\
5936 | Cluster GeneralCommissioning                                        | 0x0030 |
5937 |------------------------------------------------------------------------------|
5938 | Commands:                                                           |        |
5939 | * ArmFailSafe                                                       |   0x02 |
5940 | * CommissioningComplete                                             |   0x06 |
5941 | * SetFabric                                                         |   0x00 |
5942 |------------------------------------------------------------------------------|
5943 | Attributes:                                                         |        |
5944 | * FabricId                                                          | 0x0000 |
5945 | * Breadcrumb                                                        | 0x0001 |
5946 | * ClusterRevision                                                   | 0xFFFD |
5947 \*----------------------------------------------------------------------------*/
5948
5949 /*
5950  * Command ArmFailSafe
5951  */
5952 class GeneralCommissioningArmFailSafe : public ModelCommand
5953 {
5954 public:
5955     GeneralCommissioningArmFailSafe() : ModelCommand("arm-fail-safe")
5956     {
5957         AddArgument("expiryLengthSeconds", 0, UINT16_MAX, &mExpiryLengthSeconds);
5958         AddArgument("breadcrumb", 0, UINT64_MAX, &mBreadcrumb);
5959         AddArgument("timeoutMs", 0, UINT32_MAX, &mTimeoutMs);
5960         ModelCommand::AddArguments();
5961     }
5962     ~GeneralCommissioningArmFailSafe()
5963     {
5964         delete onSuccessCallback;
5965         delete onFailureCallback;
5966     }
5967
5968     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
5969     {
5970         ChipLogProgress(chipTool, "Sending cluster (0x0030) command (0x02) on endpoint %" PRIu16, endpointId);
5971
5972         chip::Controller::GeneralCommissioningCluster cluster;
5973         cluster.Associate(device, endpointId);
5974         return cluster.ArmFailSafe(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mExpiryLengthSeconds, mBreadcrumb,
5975                                    mTimeoutMs);
5976     }
5977
5978 private:
5979     chip::Callback::Callback<GeneralCommissioningClusterArmFailSafeResponseCallback> * onSuccessCallback =
5980         new chip::Callback::Callback<GeneralCommissioningClusterArmFailSafeResponseCallback>(
5981             OnGeneralCommissioningClusterArmFailSafeResponse, this);
5982     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
5983         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
5984     uint16_t mExpiryLengthSeconds;
5985     uint64_t mBreadcrumb;
5986     uint32_t mTimeoutMs;
5987 };
5988
5989 /*
5990  * Command CommissioningComplete
5991  */
5992 class GeneralCommissioningCommissioningComplete : public ModelCommand
5993 {
5994 public:
5995     GeneralCommissioningCommissioningComplete() : ModelCommand("commissioning-complete") { ModelCommand::AddArguments(); }
5996     ~GeneralCommissioningCommissioningComplete()
5997     {
5998         delete onSuccessCallback;
5999         delete onFailureCallback;
6000     }
6001
6002     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
6003     {
6004         ChipLogProgress(chipTool, "Sending cluster (0x0030) command (0x06) on endpoint %" PRIu16, endpointId);
6005
6006         chip::Controller::GeneralCommissioningCluster cluster;
6007         cluster.Associate(device, endpointId);
6008         return cluster.CommissioningComplete(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
6009     }
6010
6011 private:
6012     chip::Callback::Callback<GeneralCommissioningClusterCommissioningCompleteResponseCallback> * onSuccessCallback =
6013         new chip::Callback::Callback<GeneralCommissioningClusterCommissioningCompleteResponseCallback>(
6014             OnGeneralCommissioningClusterCommissioningCompleteResponse, this);
6015     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
6016         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
6017 };
6018
6019 /*
6020  * Command SetFabric
6021  */
6022 class GeneralCommissioningSetFabric : public ModelCommand
6023 {
6024 public:
6025     GeneralCommissioningSetFabric() : ModelCommand("set-fabric")
6026     {
6027         AddArgument("fabricId", &mFabricId);
6028         AddArgument("fabricSecret", &mFabricSecret);
6029         AddArgument("breadcrumb", 0, UINT64_MAX, &mBreadcrumb);
6030         AddArgument("timeoutMs", 0, UINT32_MAX, &mTimeoutMs);
6031         ModelCommand::AddArguments();
6032     }
6033     ~GeneralCommissioningSetFabric()
6034     {
6035         delete onSuccessCallback;
6036         delete onFailureCallback;
6037     }
6038
6039     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
6040     {
6041         ChipLogProgress(chipTool, "Sending cluster (0x0030) command (0x00) on endpoint %" PRIu16, endpointId);
6042
6043         chip::Controller::GeneralCommissioningCluster cluster;
6044         cluster.Associate(device, endpointId);
6045         return cluster.SetFabric(onSuccessCallback->Cancel(), onFailureCallback->Cancel(),
6046                                  chip::ByteSpan(chip::Uint8::from_char(mFabricId), strlen(mFabricId)),
6047                                  chip::ByteSpan(chip::Uint8::from_char(mFabricSecret), strlen(mFabricSecret)), mBreadcrumb,
6048                                  mTimeoutMs);
6049     }
6050
6051 private:
6052     chip::Callback::Callback<GeneralCommissioningClusterSetFabricResponseCallback> * onSuccessCallback =
6053         new chip::Callback::Callback<GeneralCommissioningClusterSetFabricResponseCallback>(
6054             OnGeneralCommissioningClusterSetFabricResponse, this);
6055     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
6056         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
6057     char * mFabricId;
6058     char * mFabricSecret;
6059     uint64_t mBreadcrumb;
6060     uint32_t mTimeoutMs;
6061 };
6062
6063 /*
6064  * Discover Attributes
6065  */
6066 class DiscoverGeneralCommissioningAttributes : public ModelCommand
6067 {
6068 public:
6069     DiscoverGeneralCommissioningAttributes() : ModelCommand("discover") { ModelCommand::AddArguments(); }
6070
6071     ~DiscoverGeneralCommissioningAttributes()
6072     {
6073         delete onSuccessCallback;
6074         delete onFailureCallback;
6075     }
6076
6077     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
6078     {
6079         ChipLogProgress(chipTool, "Sending cluster (0x0000) command (0x0C) on endpoint %" PRIu16, endpointId);
6080
6081         chip::Controller::GeneralCommissioningCluster cluster;
6082         cluster.Associate(device, endpointId);
6083         return cluster.DiscoverAttributes(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
6084     }
6085
6086 private:
6087     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
6088         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
6089     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
6090         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
6091 };
6092
6093 /*
6094  * Attribute FabricId
6095  */
6096 class ReadGeneralCommissioningFabricId : public ModelCommand
6097 {
6098 public:
6099     ReadGeneralCommissioningFabricId() : ModelCommand("read")
6100     {
6101         AddArgument("attr-name", "fabric-id");
6102         ModelCommand::AddArguments();
6103     }
6104
6105     ~ReadGeneralCommissioningFabricId()
6106     {
6107         delete onSuccessCallback;
6108         delete onFailureCallback;
6109     }
6110
6111     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
6112     {
6113         ChipLogProgress(chipTool, "Sending cluster (0x0030) command (0x00) on endpoint %" PRIu16, endpointId);
6114
6115         chip::Controller::GeneralCommissioningCluster cluster;
6116         cluster.Associate(device, endpointId);
6117         return cluster.ReadAttributeFabricId(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
6118     }
6119
6120 private:
6121     chip::Callback::Callback<StringAttributeCallback> * onSuccessCallback =
6122         new chip::Callback::Callback<StringAttributeCallback>(OnStringAttributeResponse, this);
6123     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
6124         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
6125 };
6126
6127 /*
6128  * Attribute Breadcrumb
6129  */
6130 class ReadGeneralCommissioningBreadcrumb : public ModelCommand
6131 {
6132 public:
6133     ReadGeneralCommissioningBreadcrumb() : ModelCommand("read")
6134     {
6135         AddArgument("attr-name", "breadcrumb");
6136         ModelCommand::AddArguments();
6137     }
6138
6139     ~ReadGeneralCommissioningBreadcrumb()
6140     {
6141         delete onSuccessCallback;
6142         delete onFailureCallback;
6143     }
6144
6145     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
6146     {
6147         ChipLogProgress(chipTool, "Sending cluster (0x0030) command (0x00) on endpoint %" PRIu16, endpointId);
6148
6149         chip::Controller::GeneralCommissioningCluster cluster;
6150         cluster.Associate(device, endpointId);
6151         return cluster.ReadAttributeBreadcrumb(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
6152     }
6153
6154 private:
6155     chip::Callback::Callback<Int64uAttributeCallback> * onSuccessCallback =
6156         new chip::Callback::Callback<Int64uAttributeCallback>(OnInt64uAttributeResponse, this);
6157     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
6158         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
6159 };
6160
6161 class WriteGeneralCommissioningBreadcrumb : public ModelCommand
6162 {
6163 public:
6164     WriteGeneralCommissioningBreadcrumb() : ModelCommand("write")
6165     {
6166         AddArgument("attr-name", "breadcrumb");
6167         AddArgument("attr-value", 0, UINT64_MAX, &mValue);
6168         ModelCommand::AddArguments();
6169     }
6170
6171     ~WriteGeneralCommissioningBreadcrumb()
6172     {
6173         delete onSuccessCallback;
6174         delete onFailureCallback;
6175     }
6176
6177     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
6178     {
6179         ChipLogProgress(chipTool, "Sending cluster (0x0030) command (0x01) on endpoint %" PRIu16, endpointId);
6180
6181         chip::Controller::GeneralCommissioningCluster cluster;
6182         cluster.Associate(device, endpointId);
6183         return cluster.WriteAttributeBreadcrumb(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue);
6184     }
6185
6186 private:
6187     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
6188         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
6189     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
6190         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
6191     uint64_t mValue;
6192 };
6193
6194 /*
6195  * Attribute ClusterRevision
6196  */
6197 class ReadGeneralCommissioningClusterRevision : public ModelCommand
6198 {
6199 public:
6200     ReadGeneralCommissioningClusterRevision() : ModelCommand("read")
6201     {
6202         AddArgument("attr-name", "cluster-revision");
6203         ModelCommand::AddArguments();
6204     }
6205
6206     ~ReadGeneralCommissioningClusterRevision()
6207     {
6208         delete onSuccessCallback;
6209         delete onFailureCallback;
6210     }
6211
6212     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
6213     {
6214         ChipLogProgress(chipTool, "Sending cluster (0x0030) command (0x00) on endpoint %" PRIu16, endpointId);
6215
6216         chip::Controller::GeneralCommissioningCluster cluster;
6217         cluster.Associate(device, endpointId);
6218         return cluster.ReadAttributeClusterRevision(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
6219     }
6220
6221 private:
6222     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
6223         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
6224     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
6225         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
6226 };
6227
6228 /*----------------------------------------------------------------------------*\
6229 | Cluster Groups                                                      | 0x0004 |
6230 |------------------------------------------------------------------------------|
6231 | Commands:                                                           |        |
6232 | * AddGroup                                                          |   0x00 |
6233 | * AddGroupIfIdentifying                                             |   0x05 |
6234 | * GetGroupMembership                                                |   0x02 |
6235 | * RemoveAllGroups                                                   |   0x04 |
6236 | * RemoveGroup                                                       |   0x03 |
6237 | * ViewGroup                                                         |   0x01 |
6238 |------------------------------------------------------------------------------|
6239 | Attributes:                                                         |        |
6240 | * NameSupport                                                       | 0x0000 |
6241 | * ClusterRevision                                                   | 0xFFFD |
6242 \*----------------------------------------------------------------------------*/
6243
6244 /*
6245  * Command AddGroup
6246  */
6247 class GroupsAddGroup : public ModelCommand
6248 {
6249 public:
6250     GroupsAddGroup() : ModelCommand("add-group")
6251     {
6252         AddArgument("groupId", 0, UINT16_MAX, &mGroupId);
6253         AddArgument("groupName", &mGroupName);
6254         ModelCommand::AddArguments();
6255     }
6256     ~GroupsAddGroup()
6257     {
6258         delete onSuccessCallback;
6259         delete onFailureCallback;
6260     }
6261
6262     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
6263     {
6264         ChipLogProgress(chipTool, "Sending cluster (0x0004) command (0x00) on endpoint %" PRIu16, endpointId);
6265
6266         chip::Controller::GroupsCluster cluster;
6267         cluster.Associate(device, endpointId);
6268         return cluster.AddGroup(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mGroupId,
6269                                 chip::ByteSpan(chip::Uint8::from_char(mGroupName), strlen(mGroupName)));
6270     }
6271
6272 private:
6273     chip::Callback::Callback<GroupsClusterAddGroupResponseCallback> * onSuccessCallback =
6274         new chip::Callback::Callback<GroupsClusterAddGroupResponseCallback>(OnGroupsClusterAddGroupResponse, this);
6275     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
6276         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
6277     uint16_t mGroupId;
6278     char * mGroupName;
6279 };
6280
6281 /*
6282  * Command AddGroupIfIdentifying
6283  */
6284 class GroupsAddGroupIfIdentifying : public ModelCommand
6285 {
6286 public:
6287     GroupsAddGroupIfIdentifying() : ModelCommand("add-group-if-identifying")
6288     {
6289         AddArgument("groupId", 0, UINT16_MAX, &mGroupId);
6290         AddArgument("groupName", &mGroupName);
6291         ModelCommand::AddArguments();
6292     }
6293     ~GroupsAddGroupIfIdentifying()
6294     {
6295         delete onSuccessCallback;
6296         delete onFailureCallback;
6297     }
6298
6299     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
6300     {
6301         ChipLogProgress(chipTool, "Sending cluster (0x0004) command (0x05) on endpoint %" PRIu16, endpointId);
6302
6303         chip::Controller::GroupsCluster cluster;
6304         cluster.Associate(device, endpointId);
6305         return cluster.AddGroupIfIdentifying(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mGroupId,
6306                                              chip::ByteSpan(chip::Uint8::from_char(mGroupName), strlen(mGroupName)));
6307     }
6308
6309 private:
6310     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
6311         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
6312     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
6313         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
6314     uint16_t mGroupId;
6315     char * mGroupName;
6316 };
6317
6318 /*
6319  * Command GetGroupMembership
6320  */
6321 class GroupsGetGroupMembership : public ModelCommand
6322 {
6323 public:
6324     GroupsGetGroupMembership() : ModelCommand("get-group-membership")
6325     {
6326         AddArgument("groupCount", 0, UINT8_MAX, &mGroupCount);
6327         AddArgument("groupList", 0, UINT16_MAX, &mGroupList);
6328         ModelCommand::AddArguments();
6329     }
6330     ~GroupsGetGroupMembership()
6331     {
6332         delete onSuccessCallback;
6333         delete onFailureCallback;
6334     }
6335
6336     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
6337     {
6338         ChipLogProgress(chipTool, "Sending cluster (0x0004) command (0x02) on endpoint %" PRIu16, endpointId);
6339
6340         chip::Controller::GroupsCluster cluster;
6341         cluster.Associate(device, endpointId);
6342         return cluster.GetGroupMembership(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mGroupCount, mGroupList);
6343     }
6344
6345 private:
6346     chip::Callback::Callback<GroupsClusterGetGroupMembershipResponseCallback> * onSuccessCallback =
6347         new chip::Callback::Callback<GroupsClusterGetGroupMembershipResponseCallback>(OnGroupsClusterGetGroupMembershipResponse,
6348                                                                                       this);
6349     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
6350         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
6351     uint8_t mGroupCount;
6352     uint16_t mGroupList;
6353 };
6354
6355 /*
6356  * Command RemoveAllGroups
6357  */
6358 class GroupsRemoveAllGroups : public ModelCommand
6359 {
6360 public:
6361     GroupsRemoveAllGroups() : ModelCommand("remove-all-groups") { ModelCommand::AddArguments(); }
6362     ~GroupsRemoveAllGroups()
6363     {
6364         delete onSuccessCallback;
6365         delete onFailureCallback;
6366     }
6367
6368     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
6369     {
6370         ChipLogProgress(chipTool, "Sending cluster (0x0004) command (0x04) on endpoint %" PRIu16, endpointId);
6371
6372         chip::Controller::GroupsCluster cluster;
6373         cluster.Associate(device, endpointId);
6374         return cluster.RemoveAllGroups(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
6375     }
6376
6377 private:
6378     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
6379         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
6380     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
6381         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
6382 };
6383
6384 /*
6385  * Command RemoveGroup
6386  */
6387 class GroupsRemoveGroup : public ModelCommand
6388 {
6389 public:
6390     GroupsRemoveGroup() : ModelCommand("remove-group")
6391     {
6392         AddArgument("groupId", 0, UINT16_MAX, &mGroupId);
6393         ModelCommand::AddArguments();
6394     }
6395     ~GroupsRemoveGroup()
6396     {
6397         delete onSuccessCallback;
6398         delete onFailureCallback;
6399     }
6400
6401     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
6402     {
6403         ChipLogProgress(chipTool, "Sending cluster (0x0004) command (0x03) on endpoint %" PRIu16, endpointId);
6404
6405         chip::Controller::GroupsCluster cluster;
6406         cluster.Associate(device, endpointId);
6407         return cluster.RemoveGroup(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mGroupId);
6408     }
6409
6410 private:
6411     chip::Callback::Callback<GroupsClusterRemoveGroupResponseCallback> * onSuccessCallback =
6412         new chip::Callback::Callback<GroupsClusterRemoveGroupResponseCallback>(OnGroupsClusterRemoveGroupResponse, this);
6413     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
6414         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
6415     uint16_t mGroupId;
6416 };
6417
6418 /*
6419  * Command ViewGroup
6420  */
6421 class GroupsViewGroup : public ModelCommand
6422 {
6423 public:
6424     GroupsViewGroup() : ModelCommand("view-group")
6425     {
6426         AddArgument("groupId", 0, UINT16_MAX, &mGroupId);
6427         ModelCommand::AddArguments();
6428     }
6429     ~GroupsViewGroup()
6430     {
6431         delete onSuccessCallback;
6432         delete onFailureCallback;
6433     }
6434
6435     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
6436     {
6437         ChipLogProgress(chipTool, "Sending cluster (0x0004) command (0x01) on endpoint %" PRIu16, endpointId);
6438
6439         chip::Controller::GroupsCluster cluster;
6440         cluster.Associate(device, endpointId);
6441         return cluster.ViewGroup(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mGroupId);
6442     }
6443
6444 private:
6445     chip::Callback::Callback<GroupsClusterViewGroupResponseCallback> * onSuccessCallback =
6446         new chip::Callback::Callback<GroupsClusterViewGroupResponseCallback>(OnGroupsClusterViewGroupResponse, this);
6447     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
6448         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
6449     uint16_t mGroupId;
6450 };
6451
6452 /*
6453  * Discover Attributes
6454  */
6455 class DiscoverGroupsAttributes : public ModelCommand
6456 {
6457 public:
6458     DiscoverGroupsAttributes() : ModelCommand("discover") { ModelCommand::AddArguments(); }
6459
6460     ~DiscoverGroupsAttributes()
6461     {
6462         delete onSuccessCallback;
6463         delete onFailureCallback;
6464     }
6465
6466     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
6467     {
6468         ChipLogProgress(chipTool, "Sending cluster (0x0000) command (0x0C) on endpoint %" PRIu16, endpointId);
6469
6470         chip::Controller::GroupsCluster cluster;
6471         cluster.Associate(device, endpointId);
6472         return cluster.DiscoverAttributes(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
6473     }
6474
6475 private:
6476     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
6477         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
6478     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
6479         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
6480 };
6481
6482 /*
6483  * Attribute NameSupport
6484  */
6485 class ReadGroupsNameSupport : public ModelCommand
6486 {
6487 public:
6488     ReadGroupsNameSupport() : ModelCommand("read")
6489     {
6490         AddArgument("attr-name", "name-support");
6491         ModelCommand::AddArguments();
6492     }
6493
6494     ~ReadGroupsNameSupport()
6495     {
6496         delete onSuccessCallback;
6497         delete onFailureCallback;
6498     }
6499
6500     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
6501     {
6502         ChipLogProgress(chipTool, "Sending cluster (0x0004) command (0x00) on endpoint %" PRIu16, endpointId);
6503
6504         chip::Controller::GroupsCluster cluster;
6505         cluster.Associate(device, endpointId);
6506         return cluster.ReadAttributeNameSupport(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
6507     }
6508
6509 private:
6510     chip::Callback::Callback<Int8uAttributeCallback> * onSuccessCallback =
6511         new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
6512     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
6513         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
6514 };
6515
6516 /*
6517  * Attribute ClusterRevision
6518  */
6519 class ReadGroupsClusterRevision : public ModelCommand
6520 {
6521 public:
6522     ReadGroupsClusterRevision() : ModelCommand("read")
6523     {
6524         AddArgument("attr-name", "cluster-revision");
6525         ModelCommand::AddArguments();
6526     }
6527
6528     ~ReadGroupsClusterRevision()
6529     {
6530         delete onSuccessCallback;
6531         delete onFailureCallback;
6532     }
6533
6534     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
6535     {
6536         ChipLogProgress(chipTool, "Sending cluster (0x0004) command (0x00) on endpoint %" PRIu16, endpointId);
6537
6538         chip::Controller::GroupsCluster cluster;
6539         cluster.Associate(device, endpointId);
6540         return cluster.ReadAttributeClusterRevision(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
6541     }
6542
6543 private:
6544     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
6545         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
6546     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
6547         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
6548 };
6549
6550 /*----------------------------------------------------------------------------*\
6551 | Cluster Identify                                                    | 0x0003 |
6552 |------------------------------------------------------------------------------|
6553 | Commands:                                                           |        |
6554 | * Identify                                                          |   0x00 |
6555 | * IdentifyQuery                                                     |   0x01 |
6556 |------------------------------------------------------------------------------|
6557 | Attributes:                                                         |        |
6558 | * IdentifyTime                                                      | 0x0000 |
6559 | * ClusterRevision                                                   | 0xFFFD |
6560 \*----------------------------------------------------------------------------*/
6561
6562 /*
6563  * Command Identify
6564  */
6565 class IdentifyIdentify : public ModelCommand
6566 {
6567 public:
6568     IdentifyIdentify() : ModelCommand("identify")
6569     {
6570         AddArgument("identifyTime", 0, UINT16_MAX, &mIdentifyTime);
6571         ModelCommand::AddArguments();
6572     }
6573     ~IdentifyIdentify()
6574     {
6575         delete onSuccessCallback;
6576         delete onFailureCallback;
6577     }
6578
6579     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
6580     {
6581         ChipLogProgress(chipTool, "Sending cluster (0x0003) command (0x00) on endpoint %" PRIu16, endpointId);
6582
6583         chip::Controller::IdentifyCluster cluster;
6584         cluster.Associate(device, endpointId);
6585         return cluster.Identify(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mIdentifyTime);
6586     }
6587
6588 private:
6589     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
6590         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
6591     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
6592         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
6593     uint16_t mIdentifyTime;
6594 };
6595
6596 /*
6597  * Command IdentifyQuery
6598  */
6599 class IdentifyIdentifyQuery : public ModelCommand
6600 {
6601 public:
6602     IdentifyIdentifyQuery() : ModelCommand("identify-query") { ModelCommand::AddArguments(); }
6603     ~IdentifyIdentifyQuery()
6604     {
6605         delete onSuccessCallback;
6606         delete onFailureCallback;
6607     }
6608
6609     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
6610     {
6611         ChipLogProgress(chipTool, "Sending cluster (0x0003) command (0x01) on endpoint %" PRIu16, endpointId);
6612
6613         chip::Controller::IdentifyCluster cluster;
6614         cluster.Associate(device, endpointId);
6615         return cluster.IdentifyQuery(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
6616     }
6617
6618 private:
6619     chip::Callback::Callback<IdentifyClusterIdentifyQueryResponseCallback> * onSuccessCallback =
6620         new chip::Callback::Callback<IdentifyClusterIdentifyQueryResponseCallback>(OnIdentifyClusterIdentifyQueryResponse, this);
6621     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
6622         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
6623 };
6624
6625 /*
6626  * Discover Attributes
6627  */
6628 class DiscoverIdentifyAttributes : public ModelCommand
6629 {
6630 public:
6631     DiscoverIdentifyAttributes() : ModelCommand("discover") { ModelCommand::AddArguments(); }
6632
6633     ~DiscoverIdentifyAttributes()
6634     {
6635         delete onSuccessCallback;
6636         delete onFailureCallback;
6637     }
6638
6639     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
6640     {
6641         ChipLogProgress(chipTool, "Sending cluster (0x0000) command (0x0C) on endpoint %" PRIu16, endpointId);
6642
6643         chip::Controller::IdentifyCluster cluster;
6644         cluster.Associate(device, endpointId);
6645         return cluster.DiscoverAttributes(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
6646     }
6647
6648 private:
6649     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
6650         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
6651     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
6652         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
6653 };
6654
6655 /*
6656  * Attribute IdentifyTime
6657  */
6658 class ReadIdentifyIdentifyTime : public ModelCommand
6659 {
6660 public:
6661     ReadIdentifyIdentifyTime() : ModelCommand("read")
6662     {
6663         AddArgument("attr-name", "identify-time");
6664         ModelCommand::AddArguments();
6665     }
6666
6667     ~ReadIdentifyIdentifyTime()
6668     {
6669         delete onSuccessCallback;
6670         delete onFailureCallback;
6671     }
6672
6673     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
6674     {
6675         ChipLogProgress(chipTool, "Sending cluster (0x0003) command (0x00) on endpoint %" PRIu16, endpointId);
6676
6677         chip::Controller::IdentifyCluster cluster;
6678         cluster.Associate(device, endpointId);
6679         return cluster.ReadAttributeIdentifyTime(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
6680     }
6681
6682 private:
6683     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
6684         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
6685     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
6686         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
6687 };
6688
6689 class WriteIdentifyIdentifyTime : public ModelCommand
6690 {
6691 public:
6692     WriteIdentifyIdentifyTime() : ModelCommand("write")
6693     {
6694         AddArgument("attr-name", "identify-time");
6695         AddArgument("attr-value", 0, UINT16_MAX, &mValue);
6696         ModelCommand::AddArguments();
6697     }
6698
6699     ~WriteIdentifyIdentifyTime()
6700     {
6701         delete onSuccessCallback;
6702         delete onFailureCallback;
6703     }
6704
6705     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
6706     {
6707         ChipLogProgress(chipTool, "Sending cluster (0x0003) command (0x01) on endpoint %" PRIu16, endpointId);
6708
6709         chip::Controller::IdentifyCluster cluster;
6710         cluster.Associate(device, endpointId);
6711         return cluster.WriteAttributeIdentifyTime(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue);
6712     }
6713
6714 private:
6715     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
6716         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
6717     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
6718         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
6719     uint16_t mValue;
6720 };
6721
6722 /*
6723  * Attribute ClusterRevision
6724  */
6725 class ReadIdentifyClusterRevision : public ModelCommand
6726 {
6727 public:
6728     ReadIdentifyClusterRevision() : ModelCommand("read")
6729     {
6730         AddArgument("attr-name", "cluster-revision");
6731         ModelCommand::AddArguments();
6732     }
6733
6734     ~ReadIdentifyClusterRevision()
6735     {
6736         delete onSuccessCallback;
6737         delete onFailureCallback;
6738     }
6739
6740     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
6741     {
6742         ChipLogProgress(chipTool, "Sending cluster (0x0003) command (0x00) on endpoint %" PRIu16, endpointId);
6743
6744         chip::Controller::IdentifyCluster cluster;
6745         cluster.Associate(device, endpointId);
6746         return cluster.ReadAttributeClusterRevision(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
6747     }
6748
6749 private:
6750     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
6751         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
6752     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
6753         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
6754 };
6755
6756 /*----------------------------------------------------------------------------*\
6757 | Cluster LevelControl                                                | 0x0008 |
6758 |------------------------------------------------------------------------------|
6759 | Commands:                                                           |        |
6760 | * Move                                                              |   0x01 |
6761 | * MoveToLevel                                                       |   0x00 |
6762 | * MoveToLevelWithOnOff                                              |   0x04 |
6763 | * MoveWithOnOff                                                     |   0x05 |
6764 | * Step                                                              |   0x02 |
6765 | * StepWithOnOff                                                     |   0x06 |
6766 | * Stop                                                              |   0x03 |
6767 | * StopWithOnOff                                                     |   0x07 |
6768 |------------------------------------------------------------------------------|
6769 | Attributes:                                                         |        |
6770 | * CurrentLevel                                                      | 0x0000 |
6771 | * ClusterRevision                                                   | 0xFFFD |
6772 \*----------------------------------------------------------------------------*/
6773
6774 /*
6775  * Command Move
6776  */
6777 class LevelControlMove : public ModelCommand
6778 {
6779 public:
6780     LevelControlMove() : ModelCommand("move")
6781     {
6782         AddArgument("moveMode", 0, UINT8_MAX, &mMoveMode);
6783         AddArgument("rate", 0, UINT8_MAX, &mRate);
6784         AddArgument("optionMask", 0, UINT8_MAX, &mOptionMask);
6785         AddArgument("optionOverride", 0, UINT8_MAX, &mOptionOverride);
6786         ModelCommand::AddArguments();
6787     }
6788     ~LevelControlMove()
6789     {
6790         delete onSuccessCallback;
6791         delete onFailureCallback;
6792     }
6793
6794     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
6795     {
6796         ChipLogProgress(chipTool, "Sending cluster (0x0008) command (0x01) on endpoint %" PRIu16, endpointId);
6797
6798         chip::Controller::LevelControlCluster cluster;
6799         cluster.Associate(device, endpointId);
6800         return cluster.Move(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMoveMode, mRate, mOptionMask,
6801                             mOptionOverride);
6802     }
6803
6804 private:
6805     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
6806         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
6807     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
6808         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
6809     uint8_t mMoveMode;
6810     uint8_t mRate;
6811     uint8_t mOptionMask;
6812     uint8_t mOptionOverride;
6813 };
6814
6815 /*
6816  * Command MoveToLevel
6817  */
6818 class LevelControlMoveToLevel : public ModelCommand
6819 {
6820 public:
6821     LevelControlMoveToLevel() : ModelCommand("move-to-level")
6822     {
6823         AddArgument("level", 0, UINT8_MAX, &mLevel);
6824         AddArgument("transitionTime", 0, UINT16_MAX, &mTransitionTime);
6825         AddArgument("optionMask", 0, UINT8_MAX, &mOptionMask);
6826         AddArgument("optionOverride", 0, UINT8_MAX, &mOptionOverride);
6827         ModelCommand::AddArguments();
6828     }
6829     ~LevelControlMoveToLevel()
6830     {
6831         delete onSuccessCallback;
6832         delete onFailureCallback;
6833     }
6834
6835     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
6836     {
6837         ChipLogProgress(chipTool, "Sending cluster (0x0008) command (0x00) on endpoint %" PRIu16, endpointId);
6838
6839         chip::Controller::LevelControlCluster cluster;
6840         cluster.Associate(device, endpointId);
6841         return cluster.MoveToLevel(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mLevel, mTransitionTime, mOptionMask,
6842                                    mOptionOverride);
6843     }
6844
6845 private:
6846     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
6847         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
6848     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
6849         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
6850     uint8_t mLevel;
6851     uint16_t mTransitionTime;
6852     uint8_t mOptionMask;
6853     uint8_t mOptionOverride;
6854 };
6855
6856 /*
6857  * Command MoveToLevelWithOnOff
6858  */
6859 class LevelControlMoveToLevelWithOnOff : public ModelCommand
6860 {
6861 public:
6862     LevelControlMoveToLevelWithOnOff() : ModelCommand("move-to-level-with-on-off")
6863     {
6864         AddArgument("level", 0, UINT8_MAX, &mLevel);
6865         AddArgument("transitionTime", 0, UINT16_MAX, &mTransitionTime);
6866         ModelCommand::AddArguments();
6867     }
6868     ~LevelControlMoveToLevelWithOnOff()
6869     {
6870         delete onSuccessCallback;
6871         delete onFailureCallback;
6872     }
6873
6874     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
6875     {
6876         ChipLogProgress(chipTool, "Sending cluster (0x0008) command (0x04) on endpoint %" PRIu16, endpointId);
6877
6878         chip::Controller::LevelControlCluster cluster;
6879         cluster.Associate(device, endpointId);
6880         return cluster.MoveToLevelWithOnOff(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mLevel, mTransitionTime);
6881     }
6882
6883 private:
6884     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
6885         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
6886     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
6887         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
6888     uint8_t mLevel;
6889     uint16_t mTransitionTime;
6890 };
6891
6892 /*
6893  * Command MoveWithOnOff
6894  */
6895 class LevelControlMoveWithOnOff : public ModelCommand
6896 {
6897 public:
6898     LevelControlMoveWithOnOff() : ModelCommand("move-with-on-off")
6899     {
6900         AddArgument("moveMode", 0, UINT8_MAX, &mMoveMode);
6901         AddArgument("rate", 0, UINT8_MAX, &mRate);
6902         ModelCommand::AddArguments();
6903     }
6904     ~LevelControlMoveWithOnOff()
6905     {
6906         delete onSuccessCallback;
6907         delete onFailureCallback;
6908     }
6909
6910     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
6911     {
6912         ChipLogProgress(chipTool, "Sending cluster (0x0008) command (0x05) on endpoint %" PRIu16, endpointId);
6913
6914         chip::Controller::LevelControlCluster cluster;
6915         cluster.Associate(device, endpointId);
6916         return cluster.MoveWithOnOff(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMoveMode, mRate);
6917     }
6918
6919 private:
6920     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
6921         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
6922     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
6923         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
6924     uint8_t mMoveMode;
6925     uint8_t mRate;
6926 };
6927
6928 /*
6929  * Command Step
6930  */
6931 class LevelControlStep : public ModelCommand
6932 {
6933 public:
6934     LevelControlStep() : ModelCommand("step")
6935     {
6936         AddArgument("stepMode", 0, UINT8_MAX, &mStepMode);
6937         AddArgument("stepSize", 0, UINT8_MAX, &mStepSize);
6938         AddArgument("transitionTime", 0, UINT16_MAX, &mTransitionTime);
6939         AddArgument("optionMask", 0, UINT8_MAX, &mOptionMask);
6940         AddArgument("optionOverride", 0, UINT8_MAX, &mOptionOverride);
6941         ModelCommand::AddArguments();
6942     }
6943     ~LevelControlStep()
6944     {
6945         delete onSuccessCallback;
6946         delete onFailureCallback;
6947     }
6948
6949     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
6950     {
6951         ChipLogProgress(chipTool, "Sending cluster (0x0008) command (0x02) on endpoint %" PRIu16, endpointId);
6952
6953         chip::Controller::LevelControlCluster cluster;
6954         cluster.Associate(device, endpointId);
6955         return cluster.Step(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mStepMode, mStepSize, mTransitionTime,
6956                             mOptionMask, mOptionOverride);
6957     }
6958
6959 private:
6960     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
6961         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
6962     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
6963         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
6964     uint8_t mStepMode;
6965     uint8_t mStepSize;
6966     uint16_t mTransitionTime;
6967     uint8_t mOptionMask;
6968     uint8_t mOptionOverride;
6969 };
6970
6971 /*
6972  * Command StepWithOnOff
6973  */
6974 class LevelControlStepWithOnOff : public ModelCommand
6975 {
6976 public:
6977     LevelControlStepWithOnOff() : ModelCommand("step-with-on-off")
6978     {
6979         AddArgument("stepMode", 0, UINT8_MAX, &mStepMode);
6980         AddArgument("stepSize", 0, UINT8_MAX, &mStepSize);
6981         AddArgument("transitionTime", 0, UINT16_MAX, &mTransitionTime);
6982         ModelCommand::AddArguments();
6983     }
6984     ~LevelControlStepWithOnOff()
6985     {
6986         delete onSuccessCallback;
6987         delete onFailureCallback;
6988     }
6989
6990     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
6991     {
6992         ChipLogProgress(chipTool, "Sending cluster (0x0008) command (0x06) on endpoint %" PRIu16, endpointId);
6993
6994         chip::Controller::LevelControlCluster cluster;
6995         cluster.Associate(device, endpointId);
6996         return cluster.StepWithOnOff(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mStepMode, mStepSize,
6997                                      mTransitionTime);
6998     }
6999
7000 private:
7001     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
7002         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
7003     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
7004         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
7005     uint8_t mStepMode;
7006     uint8_t mStepSize;
7007     uint16_t mTransitionTime;
7008 };
7009
7010 /*
7011  * Command Stop
7012  */
7013 class LevelControlStop : public ModelCommand
7014 {
7015 public:
7016     LevelControlStop() : ModelCommand("stop")
7017     {
7018         AddArgument("optionMask", 0, UINT8_MAX, &mOptionMask);
7019         AddArgument("optionOverride", 0, UINT8_MAX, &mOptionOverride);
7020         ModelCommand::AddArguments();
7021     }
7022     ~LevelControlStop()
7023     {
7024         delete onSuccessCallback;
7025         delete onFailureCallback;
7026     }
7027
7028     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
7029     {
7030         ChipLogProgress(chipTool, "Sending cluster (0x0008) command (0x03) on endpoint %" PRIu16, endpointId);
7031
7032         chip::Controller::LevelControlCluster cluster;
7033         cluster.Associate(device, endpointId);
7034         return cluster.Stop(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mOptionMask, mOptionOverride);
7035     }
7036
7037 private:
7038     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
7039         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
7040     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
7041         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
7042     uint8_t mOptionMask;
7043     uint8_t mOptionOverride;
7044 };
7045
7046 /*
7047  * Command StopWithOnOff
7048  */
7049 class LevelControlStopWithOnOff : public ModelCommand
7050 {
7051 public:
7052     LevelControlStopWithOnOff() : ModelCommand("stop-with-on-off") { ModelCommand::AddArguments(); }
7053     ~LevelControlStopWithOnOff()
7054     {
7055         delete onSuccessCallback;
7056         delete onFailureCallback;
7057     }
7058
7059     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
7060     {
7061         ChipLogProgress(chipTool, "Sending cluster (0x0008) command (0x07) on endpoint %" PRIu16, endpointId);
7062
7063         chip::Controller::LevelControlCluster cluster;
7064         cluster.Associate(device, endpointId);
7065         return cluster.StopWithOnOff(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
7066     }
7067
7068 private:
7069     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
7070         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
7071     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
7072         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
7073 };
7074
7075 /*
7076  * Discover Attributes
7077  */
7078 class DiscoverLevelControlAttributes : public ModelCommand
7079 {
7080 public:
7081     DiscoverLevelControlAttributes() : ModelCommand("discover") { ModelCommand::AddArguments(); }
7082
7083     ~DiscoverLevelControlAttributes()
7084     {
7085         delete onSuccessCallback;
7086         delete onFailureCallback;
7087     }
7088
7089     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
7090     {
7091         ChipLogProgress(chipTool, "Sending cluster (0x0000) command (0x0C) on endpoint %" PRIu16, endpointId);
7092
7093         chip::Controller::LevelControlCluster cluster;
7094         cluster.Associate(device, endpointId);
7095         return cluster.DiscoverAttributes(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
7096     }
7097
7098 private:
7099     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
7100         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
7101     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
7102         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
7103 };
7104
7105 /*
7106  * Attribute CurrentLevel
7107  */
7108 class ReadLevelControlCurrentLevel : public ModelCommand
7109 {
7110 public:
7111     ReadLevelControlCurrentLevel() : ModelCommand("read")
7112     {
7113         AddArgument("attr-name", "current-level");
7114         ModelCommand::AddArguments();
7115     }
7116
7117     ~ReadLevelControlCurrentLevel()
7118     {
7119         delete onSuccessCallback;
7120         delete onFailureCallback;
7121     }
7122
7123     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
7124     {
7125         ChipLogProgress(chipTool, "Sending cluster (0x0008) command (0x00) on endpoint %" PRIu16, endpointId);
7126
7127         chip::Controller::LevelControlCluster cluster;
7128         cluster.Associate(device, endpointId);
7129         return cluster.ReadAttributeCurrentLevel(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
7130     }
7131
7132 private:
7133     chip::Callback::Callback<Int8uAttributeCallback> * onSuccessCallback =
7134         new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
7135     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
7136         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
7137 };
7138
7139 class ReportLevelControlCurrentLevel : public ModelCommand
7140 {
7141 public:
7142     ReportLevelControlCurrentLevel() : ModelCommand("report")
7143     {
7144         AddArgument("attr-name", "current-level");
7145         AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval);
7146         AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval);
7147         AddArgument("change", 0, UINT8_MAX, &mChange);
7148         ModelCommand::AddArguments();
7149     }
7150
7151     ~ReportLevelControlCurrentLevel()
7152     {
7153         delete onSuccessCallback;
7154         delete onFailureCallback;
7155         delete onReportCallback;
7156     }
7157
7158     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
7159     {
7160         ChipLogProgress(chipTool, "Sending cluster (0x0008) command (0x06) on endpoint %" PRIu16, endpointId);
7161
7162         chip::Controller::LevelControlCluster cluster;
7163         cluster.Associate(device, endpointId);
7164
7165         CHIP_ERROR err = cluster.ReportAttributeCurrentLevel(onReportCallback->Cancel());
7166         if (err != CHIP_NO_ERROR)
7167         {
7168             return err;
7169         }
7170
7171         return cluster.ConfigureAttributeCurrentLevel(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval,
7172                                                       mMaxInterval, mChange);
7173     }
7174
7175 private:
7176     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
7177         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
7178     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
7179         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
7180     chip::Callback::Callback<Int8uAttributeCallback> * onReportCallback =
7181         new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
7182     uint16_t mMinInterval;
7183     uint16_t mMaxInterval;
7184     uint8_t mChange;
7185 };
7186
7187 /*
7188  * Attribute ClusterRevision
7189  */
7190 class ReadLevelControlClusterRevision : public ModelCommand
7191 {
7192 public:
7193     ReadLevelControlClusterRevision() : ModelCommand("read")
7194     {
7195         AddArgument("attr-name", "cluster-revision");
7196         ModelCommand::AddArguments();
7197     }
7198
7199     ~ReadLevelControlClusterRevision()
7200     {
7201         delete onSuccessCallback;
7202         delete onFailureCallback;
7203     }
7204
7205     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
7206     {
7207         ChipLogProgress(chipTool, "Sending cluster (0x0008) command (0x00) on endpoint %" PRIu16, endpointId);
7208
7209         chip::Controller::LevelControlCluster cluster;
7210         cluster.Associate(device, endpointId);
7211         return cluster.ReadAttributeClusterRevision(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
7212     }
7213
7214 private:
7215     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
7216         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
7217     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
7218         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
7219 };
7220
7221 /*----------------------------------------------------------------------------*\
7222 | Cluster LowPower                                                    | 0x0508 |
7223 |------------------------------------------------------------------------------|
7224 | Commands:                                                           |        |
7225 | * Sleep                                                             |   0x00 |
7226 |------------------------------------------------------------------------------|
7227 | Attributes:                                                         |        |
7228 | * ClusterRevision                                                   | 0xFFFD |
7229 \*----------------------------------------------------------------------------*/
7230
7231 /*
7232  * Command Sleep
7233  */
7234 class LowPowerSleep : public ModelCommand
7235 {
7236 public:
7237     LowPowerSleep() : ModelCommand("sleep") { ModelCommand::AddArguments(); }
7238     ~LowPowerSleep()
7239     {
7240         delete onSuccessCallback;
7241         delete onFailureCallback;
7242     }
7243
7244     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
7245     {
7246         ChipLogProgress(chipTool, "Sending cluster (0x0508) command (0x00) on endpoint %" PRIu16, endpointId);
7247
7248         chip::Controller::LowPowerCluster cluster;
7249         cluster.Associate(device, endpointId);
7250         return cluster.Sleep(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
7251     }
7252
7253 private:
7254     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
7255         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
7256     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
7257         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
7258 };
7259
7260 /*
7261  * Discover Attributes
7262  */
7263 class DiscoverLowPowerAttributes : public ModelCommand
7264 {
7265 public:
7266     DiscoverLowPowerAttributes() : ModelCommand("discover") { ModelCommand::AddArguments(); }
7267
7268     ~DiscoverLowPowerAttributes()
7269     {
7270         delete onSuccessCallback;
7271         delete onFailureCallback;
7272     }
7273
7274     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
7275     {
7276         ChipLogProgress(chipTool, "Sending cluster (0x0000) command (0x0C) on endpoint %" PRIu16, endpointId);
7277
7278         chip::Controller::LowPowerCluster cluster;
7279         cluster.Associate(device, endpointId);
7280         return cluster.DiscoverAttributes(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
7281     }
7282
7283 private:
7284     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
7285         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
7286     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
7287         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
7288 };
7289
7290 /*
7291  * Attribute ClusterRevision
7292  */
7293 class ReadLowPowerClusterRevision : public ModelCommand
7294 {
7295 public:
7296     ReadLowPowerClusterRevision() : ModelCommand("read")
7297     {
7298         AddArgument("attr-name", "cluster-revision");
7299         ModelCommand::AddArguments();
7300     }
7301
7302     ~ReadLowPowerClusterRevision()
7303     {
7304         delete onSuccessCallback;
7305         delete onFailureCallback;
7306     }
7307
7308     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
7309     {
7310         ChipLogProgress(chipTool, "Sending cluster (0x0508) command (0x00) on endpoint %" PRIu16, endpointId);
7311
7312         chip::Controller::LowPowerCluster cluster;
7313         cluster.Associate(device, endpointId);
7314         return cluster.ReadAttributeClusterRevision(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
7315     }
7316
7317 private:
7318     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
7319         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
7320     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
7321         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
7322 };
7323
7324 /*----------------------------------------------------------------------------*\
7325 | Cluster OnOff                                                       | 0x0006 |
7326 |------------------------------------------------------------------------------|
7327 | Commands:                                                           |        |
7328 | * Off                                                               |   0x00 |
7329 | * On                                                                |   0x01 |
7330 | * Toggle                                                            |   0x02 |
7331 |------------------------------------------------------------------------------|
7332 | Attributes:                                                         |        |
7333 | * OnOff                                                             | 0x0000 |
7334 | * ClusterRevision                                                   | 0xFFFD |
7335 \*----------------------------------------------------------------------------*/
7336
7337 /*
7338  * Command Off
7339  */
7340 class OnOffOff : public ModelCommand
7341 {
7342 public:
7343     OnOffOff() : ModelCommand("off") { ModelCommand::AddArguments(); }
7344     ~OnOffOff()
7345     {
7346         delete onSuccessCallback;
7347         delete onFailureCallback;
7348     }
7349
7350     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
7351     {
7352         ChipLogProgress(chipTool, "Sending cluster (0x0006) command (0x00) on endpoint %" PRIu16, endpointId);
7353
7354         chip::Controller::OnOffCluster cluster;
7355         cluster.Associate(device, endpointId);
7356         return cluster.Off(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
7357     }
7358
7359 private:
7360     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
7361         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
7362     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
7363         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
7364 };
7365
7366 /*
7367  * Command On
7368  */
7369 class OnOffOn : public ModelCommand
7370 {
7371 public:
7372     OnOffOn() : ModelCommand("on") { ModelCommand::AddArguments(); }
7373     ~OnOffOn()
7374     {
7375         delete onSuccessCallback;
7376         delete onFailureCallback;
7377     }
7378
7379     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
7380     {
7381         ChipLogProgress(chipTool, "Sending cluster (0x0006) command (0x01) on endpoint %" PRIu16, endpointId);
7382
7383         chip::Controller::OnOffCluster cluster;
7384         cluster.Associate(device, endpointId);
7385         return cluster.On(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
7386     }
7387
7388 private:
7389     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
7390         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
7391     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
7392         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
7393 };
7394
7395 /*
7396  * Command Toggle
7397  */
7398 class OnOffToggle : public ModelCommand
7399 {
7400 public:
7401     OnOffToggle() : ModelCommand("toggle") { ModelCommand::AddArguments(); }
7402     ~OnOffToggle()
7403     {
7404         delete onSuccessCallback;
7405         delete onFailureCallback;
7406     }
7407
7408     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
7409     {
7410         ChipLogProgress(chipTool, "Sending cluster (0x0006) command (0x02) on endpoint %" PRIu16, endpointId);
7411
7412         chip::Controller::OnOffCluster cluster;
7413         cluster.Associate(device, endpointId);
7414         return cluster.Toggle(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
7415     }
7416
7417 private:
7418     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
7419         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
7420     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
7421         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
7422 };
7423
7424 /*
7425  * Discover Attributes
7426  */
7427 class DiscoverOnOffAttributes : public ModelCommand
7428 {
7429 public:
7430     DiscoverOnOffAttributes() : ModelCommand("discover") { ModelCommand::AddArguments(); }
7431
7432     ~DiscoverOnOffAttributes()
7433     {
7434         delete onSuccessCallback;
7435         delete onFailureCallback;
7436     }
7437
7438     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
7439     {
7440         ChipLogProgress(chipTool, "Sending cluster (0x0000) command (0x0C) on endpoint %" PRIu16, endpointId);
7441
7442         chip::Controller::OnOffCluster cluster;
7443         cluster.Associate(device, endpointId);
7444         return cluster.DiscoverAttributes(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
7445     }
7446
7447 private:
7448     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
7449         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
7450     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
7451         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
7452 };
7453
7454 /*
7455  * Attribute OnOff
7456  */
7457 class ReadOnOffOnOff : public ModelCommand
7458 {
7459 public:
7460     ReadOnOffOnOff() : ModelCommand("read")
7461     {
7462         AddArgument("attr-name", "on-off");
7463         ModelCommand::AddArguments();
7464     }
7465
7466     ~ReadOnOffOnOff()
7467     {
7468         delete onSuccessCallback;
7469         delete onFailureCallback;
7470     }
7471
7472     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
7473     {
7474         ChipLogProgress(chipTool, "Sending cluster (0x0006) command (0x00) on endpoint %" PRIu16, endpointId);
7475
7476         chip::Controller::OnOffCluster cluster;
7477         cluster.Associate(device, endpointId);
7478         return cluster.ReadAttributeOnOff(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
7479     }
7480
7481 private:
7482     chip::Callback::Callback<BooleanAttributeCallback> * onSuccessCallback =
7483         new chip::Callback::Callback<BooleanAttributeCallback>(OnBooleanAttributeResponse, this);
7484     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
7485         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
7486 };
7487
7488 class ReportOnOffOnOff : public ModelCommand
7489 {
7490 public:
7491     ReportOnOffOnOff() : ModelCommand("report")
7492     {
7493         AddArgument("attr-name", "on-off");
7494         AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval);
7495         AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval);
7496         ModelCommand::AddArguments();
7497     }
7498
7499     ~ReportOnOffOnOff()
7500     {
7501         delete onSuccessCallback;
7502         delete onFailureCallback;
7503         delete onReportCallback;
7504     }
7505
7506     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
7507     {
7508         ChipLogProgress(chipTool, "Sending cluster (0x0006) command (0x06) on endpoint %" PRIu16, endpointId);
7509
7510         chip::Controller::OnOffCluster cluster;
7511         cluster.Associate(device, endpointId);
7512
7513         CHIP_ERROR err = cluster.ReportAttributeOnOff(onReportCallback->Cancel());
7514         if (err != CHIP_NO_ERROR)
7515         {
7516             return err;
7517         }
7518
7519         return cluster.ConfigureAttributeOnOff(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval,
7520                                                mMaxInterval);
7521     }
7522
7523 private:
7524     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
7525         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
7526     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
7527         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
7528     chip::Callback::Callback<BooleanAttributeCallback> * onReportCallback =
7529         new chip::Callback::Callback<BooleanAttributeCallback>(OnBooleanAttributeResponse, this);
7530     uint16_t mMinInterval;
7531     uint16_t mMaxInterval;
7532 };
7533
7534 /*
7535  * Attribute ClusterRevision
7536  */
7537 class ReadOnOffClusterRevision : public ModelCommand
7538 {
7539 public:
7540     ReadOnOffClusterRevision() : ModelCommand("read")
7541     {
7542         AddArgument("attr-name", "cluster-revision");
7543         ModelCommand::AddArguments();
7544     }
7545
7546     ~ReadOnOffClusterRevision()
7547     {
7548         delete onSuccessCallback;
7549         delete onFailureCallback;
7550     }
7551
7552     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
7553     {
7554         ChipLogProgress(chipTool, "Sending cluster (0x0006) command (0x00) on endpoint %" PRIu16, endpointId);
7555
7556         chip::Controller::OnOffCluster cluster;
7557         cluster.Associate(device, endpointId);
7558         return cluster.ReadAttributeClusterRevision(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
7559     }
7560
7561 private:
7562     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
7563         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
7564     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
7565         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
7566 };
7567
7568 /*----------------------------------------------------------------------------*\
7569 | Cluster Scenes                                                      | 0x0005 |
7570 |------------------------------------------------------------------------------|
7571 | Commands:                                                           |        |
7572 | * AddScene                                                          |   0x00 |
7573 | * GetSceneMembership                                                |   0x06 |
7574 | * RecallScene                                                       |   0x05 |
7575 | * RemoveAllScenes                                                   |   0x03 |
7576 | * RemoveScene                                                       |   0x02 |
7577 | * StoreScene                                                        |   0x04 |
7578 | * ViewScene                                                         |   0x01 |
7579 |------------------------------------------------------------------------------|
7580 | Attributes:                                                         |        |
7581 | * SceneCount                                                        | 0x0000 |
7582 | * CurrentScene                                                      | 0x0001 |
7583 | * CurrentGroup                                                      | 0x0002 |
7584 | * SceneValid                                                        | 0x0003 |
7585 | * NameSupport                                                       | 0x0004 |
7586 | * ClusterRevision                                                   | 0xFFFD |
7587 \*----------------------------------------------------------------------------*/
7588
7589 /*
7590  * Command AddScene
7591  */
7592 class ScenesAddScene : public ModelCommand
7593 {
7594 public:
7595     ScenesAddScene() : ModelCommand("add-scene")
7596     {
7597         AddArgument("groupId", 0, UINT16_MAX, &mGroupId);
7598         AddArgument("sceneId", 0, UINT8_MAX, &mSceneId);
7599         AddArgument("transitionTime", 0, UINT16_MAX, &mTransitionTime);
7600         AddArgument("sceneName", &mSceneName);
7601         AddArgument("clusterId", 0, UINT16_MAX, &mClusterId);
7602         AddArgument("length", 0, UINT8_MAX, &mLength);
7603         AddArgument("value", 0, UINT8_MAX, &mValue);
7604         ModelCommand::AddArguments();
7605     }
7606     ~ScenesAddScene()
7607     {
7608         delete onSuccessCallback;
7609         delete onFailureCallback;
7610     }
7611
7612     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
7613     {
7614         ChipLogProgress(chipTool, "Sending cluster (0x0005) command (0x00) on endpoint %" PRIu16, endpointId);
7615
7616         chip::Controller::ScenesCluster cluster;
7617         cluster.Associate(device, endpointId);
7618         return cluster.AddScene(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mGroupId, mSceneId, mTransitionTime,
7619                                 chip::ByteSpan(chip::Uint8::from_char(mSceneName), strlen(mSceneName)), mClusterId, mLength,
7620                                 mValue);
7621     }
7622
7623 private:
7624     chip::Callback::Callback<ScenesClusterAddSceneResponseCallback> * onSuccessCallback =
7625         new chip::Callback::Callback<ScenesClusterAddSceneResponseCallback>(OnScenesClusterAddSceneResponse, this);
7626     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
7627         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
7628     uint16_t mGroupId;
7629     uint8_t mSceneId;
7630     uint16_t mTransitionTime;
7631     char * mSceneName;
7632     chip::ClusterId mClusterId;
7633     uint8_t mLength;
7634     uint8_t mValue;
7635 };
7636
7637 /*
7638  * Command GetSceneMembership
7639  */
7640 class ScenesGetSceneMembership : public ModelCommand
7641 {
7642 public:
7643     ScenesGetSceneMembership() : ModelCommand("get-scene-membership")
7644     {
7645         AddArgument("groupId", 0, UINT16_MAX, &mGroupId);
7646         ModelCommand::AddArguments();
7647     }
7648     ~ScenesGetSceneMembership()
7649     {
7650         delete onSuccessCallback;
7651         delete onFailureCallback;
7652     }
7653
7654     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
7655     {
7656         ChipLogProgress(chipTool, "Sending cluster (0x0005) command (0x06) on endpoint %" PRIu16, endpointId);
7657
7658         chip::Controller::ScenesCluster cluster;
7659         cluster.Associate(device, endpointId);
7660         return cluster.GetSceneMembership(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mGroupId);
7661     }
7662
7663 private:
7664     chip::Callback::Callback<ScenesClusterGetSceneMembershipResponseCallback> * onSuccessCallback =
7665         new chip::Callback::Callback<ScenesClusterGetSceneMembershipResponseCallback>(OnScenesClusterGetSceneMembershipResponse,
7666                                                                                       this);
7667     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
7668         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
7669     uint16_t mGroupId;
7670 };
7671
7672 /*
7673  * Command RecallScene
7674  */
7675 class ScenesRecallScene : public ModelCommand
7676 {
7677 public:
7678     ScenesRecallScene() : ModelCommand("recall-scene")
7679     {
7680         AddArgument("groupId", 0, UINT16_MAX, &mGroupId);
7681         AddArgument("sceneId", 0, UINT8_MAX, &mSceneId);
7682         AddArgument("transitionTime", 0, UINT16_MAX, &mTransitionTime);
7683         ModelCommand::AddArguments();
7684     }
7685     ~ScenesRecallScene()
7686     {
7687         delete onSuccessCallback;
7688         delete onFailureCallback;
7689     }
7690
7691     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
7692     {
7693         ChipLogProgress(chipTool, "Sending cluster (0x0005) command (0x05) on endpoint %" PRIu16, endpointId);
7694
7695         chip::Controller::ScenesCluster cluster;
7696         cluster.Associate(device, endpointId);
7697         return cluster.RecallScene(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mGroupId, mSceneId, mTransitionTime);
7698     }
7699
7700 private:
7701     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
7702         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
7703     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
7704         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
7705     uint16_t mGroupId;
7706     uint8_t mSceneId;
7707     uint16_t mTransitionTime;
7708 };
7709
7710 /*
7711  * Command RemoveAllScenes
7712  */
7713 class ScenesRemoveAllScenes : public ModelCommand
7714 {
7715 public:
7716     ScenesRemoveAllScenes() : ModelCommand("remove-all-scenes")
7717     {
7718         AddArgument("groupId", 0, UINT16_MAX, &mGroupId);
7719         ModelCommand::AddArguments();
7720     }
7721     ~ScenesRemoveAllScenes()
7722     {
7723         delete onSuccessCallback;
7724         delete onFailureCallback;
7725     }
7726
7727     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
7728     {
7729         ChipLogProgress(chipTool, "Sending cluster (0x0005) command (0x03) on endpoint %" PRIu16, endpointId);
7730
7731         chip::Controller::ScenesCluster cluster;
7732         cluster.Associate(device, endpointId);
7733         return cluster.RemoveAllScenes(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mGroupId);
7734     }
7735
7736 private:
7737     chip::Callback::Callback<ScenesClusterRemoveAllScenesResponseCallback> * onSuccessCallback =
7738         new chip::Callback::Callback<ScenesClusterRemoveAllScenesResponseCallback>(OnScenesClusterRemoveAllScenesResponse, this);
7739     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
7740         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
7741     uint16_t mGroupId;
7742 };
7743
7744 /*
7745  * Command RemoveScene
7746  */
7747 class ScenesRemoveScene : public ModelCommand
7748 {
7749 public:
7750     ScenesRemoveScene() : ModelCommand("remove-scene")
7751     {
7752         AddArgument("groupId", 0, UINT16_MAX, &mGroupId);
7753         AddArgument("sceneId", 0, UINT8_MAX, &mSceneId);
7754         ModelCommand::AddArguments();
7755     }
7756     ~ScenesRemoveScene()
7757     {
7758         delete onSuccessCallback;
7759         delete onFailureCallback;
7760     }
7761
7762     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
7763     {
7764         ChipLogProgress(chipTool, "Sending cluster (0x0005) command (0x02) on endpoint %" PRIu16, endpointId);
7765
7766         chip::Controller::ScenesCluster cluster;
7767         cluster.Associate(device, endpointId);
7768         return cluster.RemoveScene(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mGroupId, mSceneId);
7769     }
7770
7771 private:
7772     chip::Callback::Callback<ScenesClusterRemoveSceneResponseCallback> * onSuccessCallback =
7773         new chip::Callback::Callback<ScenesClusterRemoveSceneResponseCallback>(OnScenesClusterRemoveSceneResponse, this);
7774     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
7775         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
7776     uint16_t mGroupId;
7777     uint8_t mSceneId;
7778 };
7779
7780 /*
7781  * Command StoreScene
7782  */
7783 class ScenesStoreScene : public ModelCommand
7784 {
7785 public:
7786     ScenesStoreScene() : ModelCommand("store-scene")
7787     {
7788         AddArgument("groupId", 0, UINT16_MAX, &mGroupId);
7789         AddArgument("sceneId", 0, UINT8_MAX, &mSceneId);
7790         ModelCommand::AddArguments();
7791     }
7792     ~ScenesStoreScene()
7793     {
7794         delete onSuccessCallback;
7795         delete onFailureCallback;
7796     }
7797
7798     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
7799     {
7800         ChipLogProgress(chipTool, "Sending cluster (0x0005) command (0x04) on endpoint %" PRIu16, endpointId);
7801
7802         chip::Controller::ScenesCluster cluster;
7803         cluster.Associate(device, endpointId);
7804         return cluster.StoreScene(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mGroupId, mSceneId);
7805     }
7806
7807 private:
7808     chip::Callback::Callback<ScenesClusterStoreSceneResponseCallback> * onSuccessCallback =
7809         new chip::Callback::Callback<ScenesClusterStoreSceneResponseCallback>(OnScenesClusterStoreSceneResponse, this);
7810     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
7811         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
7812     uint16_t mGroupId;
7813     uint8_t mSceneId;
7814 };
7815
7816 /*
7817  * Command ViewScene
7818  */
7819 class ScenesViewScene : public ModelCommand
7820 {
7821 public:
7822     ScenesViewScene() : ModelCommand("view-scene")
7823     {
7824         AddArgument("groupId", 0, UINT16_MAX, &mGroupId);
7825         AddArgument("sceneId", 0, UINT8_MAX, &mSceneId);
7826         ModelCommand::AddArguments();
7827     }
7828     ~ScenesViewScene()
7829     {
7830         delete onSuccessCallback;
7831         delete onFailureCallback;
7832     }
7833
7834     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
7835     {
7836         ChipLogProgress(chipTool, "Sending cluster (0x0005) command (0x01) on endpoint %" PRIu16, endpointId);
7837
7838         chip::Controller::ScenesCluster cluster;
7839         cluster.Associate(device, endpointId);
7840         return cluster.ViewScene(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mGroupId, mSceneId);
7841     }
7842
7843 private:
7844     chip::Callback::Callback<ScenesClusterViewSceneResponseCallback> * onSuccessCallback =
7845         new chip::Callback::Callback<ScenesClusterViewSceneResponseCallback>(OnScenesClusterViewSceneResponse, this);
7846     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
7847         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
7848     uint16_t mGroupId;
7849     uint8_t mSceneId;
7850 };
7851
7852 /*
7853  * Discover Attributes
7854  */
7855 class DiscoverScenesAttributes : public ModelCommand
7856 {
7857 public:
7858     DiscoverScenesAttributes() : ModelCommand("discover") { ModelCommand::AddArguments(); }
7859
7860     ~DiscoverScenesAttributes()
7861     {
7862         delete onSuccessCallback;
7863         delete onFailureCallback;
7864     }
7865
7866     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
7867     {
7868         ChipLogProgress(chipTool, "Sending cluster (0x0000) command (0x0C) on endpoint %" PRIu16, endpointId);
7869
7870         chip::Controller::ScenesCluster cluster;
7871         cluster.Associate(device, endpointId);
7872         return cluster.DiscoverAttributes(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
7873     }
7874
7875 private:
7876     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
7877         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
7878     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
7879         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
7880 };
7881
7882 /*
7883  * Attribute SceneCount
7884  */
7885 class ReadScenesSceneCount : public ModelCommand
7886 {
7887 public:
7888     ReadScenesSceneCount() : ModelCommand("read")
7889     {
7890         AddArgument("attr-name", "scene-count");
7891         ModelCommand::AddArguments();
7892     }
7893
7894     ~ReadScenesSceneCount()
7895     {
7896         delete onSuccessCallback;
7897         delete onFailureCallback;
7898     }
7899
7900     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
7901     {
7902         ChipLogProgress(chipTool, "Sending cluster (0x0005) command (0x00) on endpoint %" PRIu16, endpointId);
7903
7904         chip::Controller::ScenesCluster cluster;
7905         cluster.Associate(device, endpointId);
7906         return cluster.ReadAttributeSceneCount(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
7907     }
7908
7909 private:
7910     chip::Callback::Callback<Int8uAttributeCallback> * onSuccessCallback =
7911         new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
7912     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
7913         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
7914 };
7915
7916 /*
7917  * Attribute CurrentScene
7918  */
7919 class ReadScenesCurrentScene : public ModelCommand
7920 {
7921 public:
7922     ReadScenesCurrentScene() : ModelCommand("read")
7923     {
7924         AddArgument("attr-name", "current-scene");
7925         ModelCommand::AddArguments();
7926     }
7927
7928     ~ReadScenesCurrentScene()
7929     {
7930         delete onSuccessCallback;
7931         delete onFailureCallback;
7932     }
7933
7934     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
7935     {
7936         ChipLogProgress(chipTool, "Sending cluster (0x0005) command (0x00) on endpoint %" PRIu16, endpointId);
7937
7938         chip::Controller::ScenesCluster cluster;
7939         cluster.Associate(device, endpointId);
7940         return cluster.ReadAttributeCurrentScene(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
7941     }
7942
7943 private:
7944     chip::Callback::Callback<Int8uAttributeCallback> * onSuccessCallback =
7945         new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
7946     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
7947         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
7948 };
7949
7950 /*
7951  * Attribute CurrentGroup
7952  */
7953 class ReadScenesCurrentGroup : public ModelCommand
7954 {
7955 public:
7956     ReadScenesCurrentGroup() : ModelCommand("read")
7957     {
7958         AddArgument("attr-name", "current-group");
7959         ModelCommand::AddArguments();
7960     }
7961
7962     ~ReadScenesCurrentGroup()
7963     {
7964         delete onSuccessCallback;
7965         delete onFailureCallback;
7966     }
7967
7968     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
7969     {
7970         ChipLogProgress(chipTool, "Sending cluster (0x0005) command (0x00) on endpoint %" PRIu16, endpointId);
7971
7972         chip::Controller::ScenesCluster cluster;
7973         cluster.Associate(device, endpointId);
7974         return cluster.ReadAttributeCurrentGroup(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
7975     }
7976
7977 private:
7978     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
7979         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
7980     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
7981         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
7982 };
7983
7984 /*
7985  * Attribute SceneValid
7986  */
7987 class ReadScenesSceneValid : public ModelCommand
7988 {
7989 public:
7990     ReadScenesSceneValid() : ModelCommand("read")
7991     {
7992         AddArgument("attr-name", "scene-valid");
7993         ModelCommand::AddArguments();
7994     }
7995
7996     ~ReadScenesSceneValid()
7997     {
7998         delete onSuccessCallback;
7999         delete onFailureCallback;
8000     }
8001
8002     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
8003     {
8004         ChipLogProgress(chipTool, "Sending cluster (0x0005) command (0x00) on endpoint %" PRIu16, endpointId);
8005
8006         chip::Controller::ScenesCluster cluster;
8007         cluster.Associate(device, endpointId);
8008         return cluster.ReadAttributeSceneValid(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
8009     }
8010
8011 private:
8012     chip::Callback::Callback<BooleanAttributeCallback> * onSuccessCallback =
8013         new chip::Callback::Callback<BooleanAttributeCallback>(OnBooleanAttributeResponse, this);
8014     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
8015         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
8016 };
8017
8018 /*
8019  * Attribute NameSupport
8020  */
8021 class ReadScenesNameSupport : public ModelCommand
8022 {
8023 public:
8024     ReadScenesNameSupport() : ModelCommand("read")
8025     {
8026         AddArgument("attr-name", "name-support");
8027         ModelCommand::AddArguments();
8028     }
8029
8030     ~ReadScenesNameSupport()
8031     {
8032         delete onSuccessCallback;
8033         delete onFailureCallback;
8034     }
8035
8036     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
8037     {
8038         ChipLogProgress(chipTool, "Sending cluster (0x0005) command (0x00) on endpoint %" PRIu16, endpointId);
8039
8040         chip::Controller::ScenesCluster cluster;
8041         cluster.Associate(device, endpointId);
8042         return cluster.ReadAttributeNameSupport(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
8043     }
8044
8045 private:
8046     chip::Callback::Callback<Int8uAttributeCallback> * onSuccessCallback =
8047         new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
8048     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
8049         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
8050 };
8051
8052 /*
8053  * Attribute ClusterRevision
8054  */
8055 class ReadScenesClusterRevision : public ModelCommand
8056 {
8057 public:
8058     ReadScenesClusterRevision() : ModelCommand("read")
8059     {
8060         AddArgument("attr-name", "cluster-revision");
8061         ModelCommand::AddArguments();
8062     }
8063
8064     ~ReadScenesClusterRevision()
8065     {
8066         delete onSuccessCallback;
8067         delete onFailureCallback;
8068     }
8069
8070     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
8071     {
8072         ChipLogProgress(chipTool, "Sending cluster (0x0005) command (0x00) on endpoint %" PRIu16, endpointId);
8073
8074         chip::Controller::ScenesCluster cluster;
8075         cluster.Associate(device, endpointId);
8076         return cluster.ReadAttributeClusterRevision(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
8077     }
8078
8079 private:
8080     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
8081         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
8082     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
8083         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
8084 };
8085
8086 /*----------------------------------------------------------------------------*\
8087 | Cluster TemperatureMeasurement                                      | 0x0402 |
8088 |------------------------------------------------------------------------------|
8089 | Commands:                                                           |        |
8090 |------------------------------------------------------------------------------|
8091 | Attributes:                                                         |        |
8092 | * MeasuredValue                                                     | 0x0000 |
8093 | * MinMeasuredValue                                                  | 0x0001 |
8094 | * MaxMeasuredValue                                                  | 0x0002 |
8095 | * ClusterRevision                                                   | 0xFFFD |
8096 \*----------------------------------------------------------------------------*/
8097
8098 /*
8099  * Discover Attributes
8100  */
8101 class DiscoverTemperatureMeasurementAttributes : public ModelCommand
8102 {
8103 public:
8104     DiscoverTemperatureMeasurementAttributes() : ModelCommand("discover") { ModelCommand::AddArguments(); }
8105
8106     ~DiscoverTemperatureMeasurementAttributes()
8107     {
8108         delete onSuccessCallback;
8109         delete onFailureCallback;
8110     }
8111
8112     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
8113     {
8114         ChipLogProgress(chipTool, "Sending cluster (0x0000) command (0x0C) on endpoint %" PRIu16, endpointId);
8115
8116         chip::Controller::TemperatureMeasurementCluster cluster;
8117         cluster.Associate(device, endpointId);
8118         return cluster.DiscoverAttributes(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
8119     }
8120
8121 private:
8122     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
8123         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
8124     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
8125         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
8126 };
8127
8128 /*
8129  * Attribute MeasuredValue
8130  */
8131 class ReadTemperatureMeasurementMeasuredValue : public ModelCommand
8132 {
8133 public:
8134     ReadTemperatureMeasurementMeasuredValue() : ModelCommand("read")
8135     {
8136         AddArgument("attr-name", "measured-value");
8137         ModelCommand::AddArguments();
8138     }
8139
8140     ~ReadTemperatureMeasurementMeasuredValue()
8141     {
8142         delete onSuccessCallback;
8143         delete onFailureCallback;
8144     }
8145
8146     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
8147     {
8148         ChipLogProgress(chipTool, "Sending cluster (0x0402) command (0x00) on endpoint %" PRIu16, endpointId);
8149
8150         chip::Controller::TemperatureMeasurementCluster cluster;
8151         cluster.Associate(device, endpointId);
8152         return cluster.ReadAttributeMeasuredValue(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
8153     }
8154
8155 private:
8156     chip::Callback::Callback<Int16sAttributeCallback> * onSuccessCallback =
8157         new chip::Callback::Callback<Int16sAttributeCallback>(OnInt16sAttributeResponse, this);
8158     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
8159         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
8160 };
8161
8162 class ReportTemperatureMeasurementMeasuredValue : public ModelCommand
8163 {
8164 public:
8165     ReportTemperatureMeasurementMeasuredValue() : ModelCommand("report")
8166     {
8167         AddArgument("attr-name", "measured-value");
8168         AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval);
8169         AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval);
8170         AddArgument("change", INT16_MIN, INT16_MAX, &mChange);
8171         ModelCommand::AddArguments();
8172     }
8173
8174     ~ReportTemperatureMeasurementMeasuredValue()
8175     {
8176         delete onSuccessCallback;
8177         delete onFailureCallback;
8178         delete onReportCallback;
8179     }
8180
8181     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
8182     {
8183         ChipLogProgress(chipTool, "Sending cluster (0x0402) command (0x06) on endpoint %" PRIu16, endpointId);
8184
8185         chip::Controller::TemperatureMeasurementCluster cluster;
8186         cluster.Associate(device, endpointId);
8187
8188         CHIP_ERROR err = cluster.ReportAttributeMeasuredValue(onReportCallback->Cancel());
8189         if (err != CHIP_NO_ERROR)
8190         {
8191             return err;
8192         }
8193
8194         return cluster.ConfigureAttributeMeasuredValue(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval,
8195                                                        mMaxInterval, mChange);
8196     }
8197
8198 private:
8199     chip::Callback::Callback<DefaultSuccessCallback> * onSuccessCallback =
8200         new chip::Callback::Callback<DefaultSuccessCallback>(OnDefaultSuccessResponse, this);
8201     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
8202         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
8203     chip::Callback::Callback<Int16sAttributeCallback> * onReportCallback =
8204         new chip::Callback::Callback<Int16sAttributeCallback>(OnInt16sAttributeResponse, this);
8205     uint16_t mMinInterval;
8206     uint16_t mMaxInterval;
8207     int16_t mChange;
8208 };
8209
8210 /*
8211  * Attribute MinMeasuredValue
8212  */
8213 class ReadTemperatureMeasurementMinMeasuredValue : public ModelCommand
8214 {
8215 public:
8216     ReadTemperatureMeasurementMinMeasuredValue() : ModelCommand("read")
8217     {
8218         AddArgument("attr-name", "min-measured-value");
8219         ModelCommand::AddArguments();
8220     }
8221
8222     ~ReadTemperatureMeasurementMinMeasuredValue()
8223     {
8224         delete onSuccessCallback;
8225         delete onFailureCallback;
8226     }
8227
8228     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
8229     {
8230         ChipLogProgress(chipTool, "Sending cluster (0x0402) command (0x00) on endpoint %" PRIu16, endpointId);
8231
8232         chip::Controller::TemperatureMeasurementCluster cluster;
8233         cluster.Associate(device, endpointId);
8234         return cluster.ReadAttributeMinMeasuredValue(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
8235     }
8236
8237 private:
8238     chip::Callback::Callback<Int16sAttributeCallback> * onSuccessCallback =
8239         new chip::Callback::Callback<Int16sAttributeCallback>(OnInt16sAttributeResponse, this);
8240     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
8241         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
8242 };
8243
8244 /*
8245  * Attribute MaxMeasuredValue
8246  */
8247 class ReadTemperatureMeasurementMaxMeasuredValue : public ModelCommand
8248 {
8249 public:
8250     ReadTemperatureMeasurementMaxMeasuredValue() : ModelCommand("read")
8251     {
8252         AddArgument("attr-name", "max-measured-value");
8253         ModelCommand::AddArguments();
8254     }
8255
8256     ~ReadTemperatureMeasurementMaxMeasuredValue()
8257     {
8258         delete onSuccessCallback;
8259         delete onFailureCallback;
8260     }
8261
8262     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
8263     {
8264         ChipLogProgress(chipTool, "Sending cluster (0x0402) command (0x00) on endpoint %" PRIu16, endpointId);
8265
8266         chip::Controller::TemperatureMeasurementCluster cluster;
8267         cluster.Associate(device, endpointId);
8268         return cluster.ReadAttributeMaxMeasuredValue(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
8269     }
8270
8271 private:
8272     chip::Callback::Callback<Int16sAttributeCallback> * onSuccessCallback =
8273         new chip::Callback::Callback<Int16sAttributeCallback>(OnInt16sAttributeResponse, this);
8274     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
8275         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
8276 };
8277
8278 /*
8279  * Attribute ClusterRevision
8280  */
8281 class ReadTemperatureMeasurementClusterRevision : public ModelCommand
8282 {
8283 public:
8284     ReadTemperatureMeasurementClusterRevision() : ModelCommand("read")
8285     {
8286         AddArgument("attr-name", "cluster-revision");
8287         ModelCommand::AddArguments();
8288     }
8289
8290     ~ReadTemperatureMeasurementClusterRevision()
8291     {
8292         delete onSuccessCallback;
8293         delete onFailureCallback;
8294     }
8295
8296     CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
8297     {
8298         ChipLogProgress(chipTool, "Sending cluster (0x0402) command (0x00) on endpoint %" PRIu16, endpointId);
8299
8300         chip::Controller::TemperatureMeasurementCluster cluster;
8301         cluster.Associate(device, endpointId);
8302         return cluster.ReadAttributeClusterRevision(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
8303     }
8304
8305 private:
8306     chip::Callback::Callback<Int16uAttributeCallback> * onSuccessCallback =
8307         new chip::Callback::Callback<Int16uAttributeCallback>(OnInt16uAttributeResponse, this);
8308     chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
8309         new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
8310 };
8311
8312 /*----------------------------------------------------------------------------*\
8313 | Register all Clusters commands                                               |
8314 \*----------------------------------------------------------------------------*/
8315 void registerClusterApplicationBasic(Commands & commands)
8316 {
8317     const char * clusterName = "ApplicationBasic";
8318
8319     commands_list clusterCommands = {
8320         make_unique<DiscoverApplicationBasicAttributes>(),  make_unique<ReadApplicationBasicVendorName>(),
8321         make_unique<ReadApplicationBasicVendorId>(),        make_unique<ReadApplicationBasicApplicationName>(),
8322         make_unique<ReadApplicationBasicProductId>(),       make_unique<ReadApplicationBasicApplicationId>(),
8323         make_unique<ReadApplicationBasicCatalogVendorId>(), make_unique<ReadApplicationBasicApplicationSatus>(),
8324         make_unique<ReadApplicationBasicClusterRevision>(),
8325     };
8326
8327     commands.Register(clusterName, clusterCommands);
8328 }
8329 void registerClusterBarrierControl(Commands & commands)
8330 {
8331     const char * clusterName = "BarrierControl";
8332
8333     commands_list clusterCommands = {
8334         make_unique<BarrierControlBarrierControlGoToPercent>(), make_unique<BarrierControlBarrierControlStop>(),
8335         make_unique<DiscoverBarrierControlAttributes>(),        make_unique<ReadBarrierControlBarrierMovingState>(),
8336         make_unique<ReadBarrierControlBarrierSafetyStatus>(),   make_unique<ReadBarrierControlBarrierCapabilities>(),
8337         make_unique<ReadBarrierControlBarrierPosition>(),       make_unique<ReadBarrierControlClusterRevision>(),
8338     };
8339
8340     commands.Register(clusterName, clusterCommands);
8341 }
8342 void registerClusterBasic(Commands & commands)
8343 {
8344     const char * clusterName = "Basic";
8345
8346     commands_list clusterCommands = {
8347         make_unique<BasicMfgSpecificPing>(),
8348         make_unique<DiscoverBasicAttributes>(),
8349         make_unique<ReadBasicInteractionModelVersion>(),
8350         make_unique<ReadBasicVendorName>(),
8351         make_unique<ReadBasicVendorID>(),
8352         make_unique<ReadBasicProductName>(),
8353         make_unique<ReadBasicProductID>(),
8354         make_unique<ReadBasicUserLabel>(),
8355         make_unique<WriteBasicUserLabel>(),
8356         make_unique<ReadBasicLocation>(),
8357         make_unique<WriteBasicLocation>(),
8358         make_unique<ReadBasicHardwareVersion>(),
8359         make_unique<ReadBasicHardwareVersionString>(),
8360         make_unique<ReadBasicSoftwareVersion>(),
8361         make_unique<ReadBasicSoftwareVersionString>(),
8362         make_unique<ReadBasicClusterRevision>(),
8363     };
8364
8365     commands.Register(clusterName, clusterCommands);
8366 }
8367 void registerClusterBinding(Commands & commands)
8368 {
8369     const char * clusterName = "Binding";
8370
8371     commands_list clusterCommands = {
8372         make_unique<BindingBind>(),
8373         make_unique<BindingUnbind>(),
8374         make_unique<DiscoverBindingAttributes>(),
8375         make_unique<ReadBindingClusterRevision>(),
8376     };
8377
8378     commands.Register(clusterName, clusterCommands);
8379 }
8380 void registerClusterColorControl(Commands & commands)
8381 {
8382     const char * clusterName = "ColorControl";
8383
8384     commands_list clusterCommands = {
8385         make_unique<ColorControlMoveColor>(),
8386         make_unique<ColorControlMoveColorTemperature>(),
8387         make_unique<ColorControlMoveHue>(),
8388         make_unique<ColorControlMoveSaturation>(),
8389         make_unique<ColorControlMoveToColor>(),
8390         make_unique<ColorControlMoveToColorTemperature>(),
8391         make_unique<ColorControlMoveToHue>(),
8392         make_unique<ColorControlMoveToHueAndSaturation>(),
8393         make_unique<ColorControlMoveToSaturation>(),
8394         make_unique<ColorControlStepColor>(),
8395         make_unique<ColorControlStepColorTemperature>(),
8396         make_unique<ColorControlStepHue>(),
8397         make_unique<ColorControlStepSaturation>(),
8398         make_unique<ColorControlStopMoveStep>(),
8399         make_unique<DiscoverColorControlAttributes>(),
8400         make_unique<ReadColorControlCurrentHue>(),
8401         make_unique<ReportColorControlCurrentHue>(),
8402         make_unique<ReadColorControlCurrentSaturation>(),
8403         make_unique<ReportColorControlCurrentSaturation>(),
8404         make_unique<ReadColorControlRemainingTime>(),
8405         make_unique<ReadColorControlCurrentX>(),
8406         make_unique<ReportColorControlCurrentX>(),
8407         make_unique<ReadColorControlCurrentY>(),
8408         make_unique<ReportColorControlCurrentY>(),
8409         make_unique<ReadColorControlDriftCompensation>(),
8410         make_unique<ReadColorControlCompensationText>(),
8411         make_unique<ReadColorControlColorTemperature>(),
8412         make_unique<ReportColorControlColorTemperature>(),
8413         make_unique<ReadColorControlColorMode>(),
8414         make_unique<ReadColorControlColorControlOptions>(),
8415         make_unique<WriteColorControlColorControlOptions>(),
8416         make_unique<ReadColorControlNumberOfPrimaries>(),
8417         make_unique<ReadColorControlPrimary1X>(),
8418         make_unique<ReadColorControlPrimary1Y>(),
8419         make_unique<ReadColorControlPrimary1Intensity>(),
8420         make_unique<ReadColorControlPrimary2X>(),
8421         make_unique<ReadColorControlPrimary2Y>(),
8422         make_unique<ReadColorControlPrimary2Intensity>(),
8423         make_unique<ReadColorControlPrimary3X>(),
8424         make_unique<ReadColorControlPrimary3Y>(),
8425         make_unique<ReadColorControlPrimary3Intensity>(),
8426         make_unique<ReadColorControlPrimary4X>(),
8427         make_unique<ReadColorControlPrimary4Y>(),
8428         make_unique<ReadColorControlPrimary4Intensity>(),
8429         make_unique<ReadColorControlPrimary5X>(),
8430         make_unique<ReadColorControlPrimary5Y>(),
8431         make_unique<ReadColorControlPrimary5Intensity>(),
8432         make_unique<ReadColorControlPrimary6X>(),
8433         make_unique<ReadColorControlPrimary6Y>(),
8434         make_unique<ReadColorControlPrimary6Intensity>(),
8435         make_unique<ReadColorControlWhitePointX>(),
8436         make_unique<WriteColorControlWhitePointX>(),
8437         make_unique<ReadColorControlWhitePointY>(),
8438         make_unique<WriteColorControlWhitePointY>(),
8439         make_unique<ReadColorControlColorPointRX>(),
8440         make_unique<WriteColorControlColorPointRX>(),
8441         make_unique<ReadColorControlColorPointRY>(),
8442         make_unique<WriteColorControlColorPointRY>(),
8443         make_unique<ReadColorControlColorPointRIntensity>(),
8444         make_unique<WriteColorControlColorPointRIntensity>(),
8445         make_unique<ReadColorControlColorPointGX>(),
8446         make_unique<WriteColorControlColorPointGX>(),
8447         make_unique<ReadColorControlColorPointGY>(),
8448         make_unique<WriteColorControlColorPointGY>(),
8449         make_unique<ReadColorControlColorPointGIntensity>(),
8450         make_unique<WriteColorControlColorPointGIntensity>(),
8451         make_unique<ReadColorControlColorPointBX>(),
8452         make_unique<WriteColorControlColorPointBX>(),
8453         make_unique<ReadColorControlColorPointBY>(),
8454         make_unique<WriteColorControlColorPointBY>(),
8455         make_unique<ReadColorControlColorPointBIntensity>(),
8456         make_unique<WriteColorControlColorPointBIntensity>(),
8457         make_unique<ReadColorControlEnhancedCurrentHue>(),
8458         make_unique<ReadColorControlEnhancedColorMode>(),
8459         make_unique<ReadColorControlColorLoopActive>(),
8460         make_unique<ReadColorControlColorLoopDirection>(),
8461         make_unique<ReadColorControlColorLoopTime>(),
8462         make_unique<ReadColorControlColorCapabilities>(),
8463         make_unique<ReadColorControlColorTempPhysicalMin>(),
8464         make_unique<ReadColorControlColorTempPhysicalMax>(),
8465         make_unique<ReadColorControlCoupleColorTempToLevelMinMireds>(),
8466         make_unique<ReadColorControlStartUpColorTemperatureMireds>(),
8467         make_unique<WriteColorControlStartUpColorTemperatureMireds>(),
8468         make_unique<ReadColorControlClusterRevision>(),
8469     };
8470
8471     commands.Register(clusterName, clusterCommands);
8472 }
8473 void registerClusterDoorLock(Commands & commands)
8474 {
8475     const char * clusterName = "DoorLock";
8476
8477     commands_list clusterCommands = {
8478         make_unique<DoorLockClearAllPins>(),
8479         make_unique<DoorLockClearAllRfids>(),
8480         make_unique<DoorLockClearHolidaySchedule>(),
8481         make_unique<DoorLockClearPin>(),
8482         make_unique<DoorLockClearRfid>(),
8483         make_unique<DoorLockClearWeekdaySchedule>(),
8484         make_unique<DoorLockClearYeardaySchedule>(),
8485         make_unique<DoorLockGetHolidaySchedule>(),
8486         make_unique<DoorLockGetLogRecord>(),
8487         make_unique<DoorLockGetPin>(),
8488         make_unique<DoorLockGetRfid>(),
8489         make_unique<DoorLockGetUserType>(),
8490         make_unique<DoorLockGetWeekdaySchedule>(),
8491         make_unique<DoorLockGetYeardaySchedule>(),
8492         make_unique<DoorLockLockDoor>(),
8493         make_unique<DoorLockSetHolidaySchedule>(),
8494         make_unique<DoorLockSetPin>(),
8495         make_unique<DoorLockSetRfid>(),
8496         make_unique<DoorLockSetUserType>(),
8497         make_unique<DoorLockSetWeekdaySchedule>(),
8498         make_unique<DoorLockSetYeardaySchedule>(),
8499         make_unique<DoorLockUnlockDoor>(),
8500         make_unique<DoorLockUnlockWithTimeout>(),
8501         make_unique<DiscoverDoorLockAttributes>(),
8502         make_unique<ReadDoorLockLockState>(),
8503         make_unique<ReportDoorLockLockState>(),
8504         make_unique<ReadDoorLockLockType>(),
8505         make_unique<ReadDoorLockActuatorEnabled>(),
8506         make_unique<ReadDoorLockClusterRevision>(),
8507     };
8508
8509     commands.Register(clusterName, clusterCommands);
8510 }
8511 void registerClusterGeneralCommissioning(Commands & commands)
8512 {
8513     const char * clusterName = "GeneralCommissioning";
8514
8515     commands_list clusterCommands = {
8516         make_unique<GeneralCommissioningArmFailSafe>(),     make_unique<GeneralCommissioningCommissioningComplete>(),
8517         make_unique<GeneralCommissioningSetFabric>(),       make_unique<DiscoverGeneralCommissioningAttributes>(),
8518         make_unique<ReadGeneralCommissioningFabricId>(),    make_unique<ReadGeneralCommissioningBreadcrumb>(),
8519         make_unique<WriteGeneralCommissioningBreadcrumb>(), make_unique<ReadGeneralCommissioningClusterRevision>(),
8520     };
8521
8522     commands.Register(clusterName, clusterCommands);
8523 }
8524 void registerClusterGroups(Commands & commands)
8525 {
8526     const char * clusterName = "Groups";
8527
8528     commands_list clusterCommands = {
8529         make_unique<GroupsAddGroup>(),
8530         make_unique<GroupsAddGroupIfIdentifying>(),
8531         make_unique<GroupsGetGroupMembership>(),
8532         make_unique<GroupsRemoveAllGroups>(),
8533         make_unique<GroupsRemoveGroup>(),
8534         make_unique<GroupsViewGroup>(),
8535         make_unique<DiscoverGroupsAttributes>(),
8536         make_unique<ReadGroupsNameSupport>(),
8537         make_unique<ReadGroupsClusterRevision>(),
8538     };
8539
8540     commands.Register(clusterName, clusterCommands);
8541 }
8542 void registerClusterIdentify(Commands & commands)
8543 {
8544     const char * clusterName = "Identify";
8545
8546     commands_list clusterCommands = {
8547         make_unique<IdentifyIdentify>(),           make_unique<IdentifyIdentifyQuery>(),
8548         make_unique<DiscoverIdentifyAttributes>(), make_unique<ReadIdentifyIdentifyTime>(),
8549         make_unique<WriteIdentifyIdentifyTime>(),  make_unique<ReadIdentifyClusterRevision>(),
8550     };
8551
8552     commands.Register(clusterName, clusterCommands);
8553 }
8554 void registerClusterLevelControl(Commands & commands)
8555 {
8556     const char * clusterName = "LevelControl";
8557
8558     commands_list clusterCommands = {
8559         make_unique<LevelControlMove>(),
8560         make_unique<LevelControlMoveToLevel>(),
8561         make_unique<LevelControlMoveToLevelWithOnOff>(),
8562         make_unique<LevelControlMoveWithOnOff>(),
8563         make_unique<LevelControlStep>(),
8564         make_unique<LevelControlStepWithOnOff>(),
8565         make_unique<LevelControlStop>(),
8566         make_unique<LevelControlStopWithOnOff>(),
8567         make_unique<DiscoverLevelControlAttributes>(),
8568         make_unique<ReadLevelControlCurrentLevel>(),
8569         make_unique<ReportLevelControlCurrentLevel>(),
8570         make_unique<ReadLevelControlClusterRevision>(),
8571     };
8572
8573     commands.Register(clusterName, clusterCommands);
8574 }
8575 void registerClusterLowPower(Commands & commands)
8576 {
8577     const char * clusterName = "LowPower";
8578
8579     commands_list clusterCommands = {
8580         make_unique<LowPowerSleep>(),
8581         make_unique<DiscoverLowPowerAttributes>(),
8582         make_unique<ReadLowPowerClusterRevision>(),
8583     };
8584
8585     commands.Register(clusterName, clusterCommands);
8586 }
8587 void registerClusterOnOff(Commands & commands)
8588 {
8589     const char * clusterName = "OnOff";
8590
8591     commands_list clusterCommands = {
8592         make_unique<OnOffOff>(),
8593         make_unique<OnOffOn>(),
8594         make_unique<OnOffToggle>(),
8595         make_unique<DiscoverOnOffAttributes>(),
8596         make_unique<ReadOnOffOnOff>(),
8597         make_unique<ReportOnOffOnOff>(),
8598         make_unique<ReadOnOffClusterRevision>(),
8599     };
8600
8601     commands.Register(clusterName, clusterCommands);
8602 }
8603 void registerClusterScenes(Commands & commands)
8604 {
8605     const char * clusterName = "Scenes";
8606
8607     commands_list clusterCommands = {
8608         make_unique<ScenesAddScene>(),         make_unique<ScenesGetSceneMembership>(),  make_unique<ScenesRecallScene>(),
8609         make_unique<ScenesRemoveAllScenes>(),  make_unique<ScenesRemoveScene>(),         make_unique<ScenesStoreScene>(),
8610         make_unique<ScenesViewScene>(),        make_unique<DiscoverScenesAttributes>(),  make_unique<ReadScenesSceneCount>(),
8611         make_unique<ReadScenesCurrentScene>(), make_unique<ReadScenesCurrentGroup>(),    make_unique<ReadScenesSceneValid>(),
8612         make_unique<ReadScenesNameSupport>(),  make_unique<ReadScenesClusterRevision>(),
8613     };
8614
8615     commands.Register(clusterName, clusterCommands);
8616 }
8617 void registerClusterTemperatureMeasurement(Commands & commands)
8618 {
8619     const char * clusterName = "TemperatureMeasurement";
8620
8621     commands_list clusterCommands = {
8622         make_unique<DiscoverTemperatureMeasurementAttributes>(),   make_unique<ReadTemperatureMeasurementMeasuredValue>(),
8623         make_unique<ReportTemperatureMeasurementMeasuredValue>(),  make_unique<ReadTemperatureMeasurementMinMeasuredValue>(),
8624         make_unique<ReadTemperatureMeasurementMaxMeasuredValue>(), make_unique<ReadTemperatureMeasurementClusterRevision>(),
8625     };
8626
8627     commands.Register(clusterName, clusterCommands);
8628 }
8629
8630 void registerClusters(Commands & commands)
8631 {
8632     registerClusterApplicationBasic(commands);
8633     registerClusterBarrierControl(commands);
8634     registerClusterBasic(commands);
8635     registerClusterBinding(commands);
8636     registerClusterColorControl(commands);
8637     registerClusterDoorLock(commands);
8638     registerClusterGeneralCommissioning(commands);
8639     registerClusterGroups(commands);
8640     registerClusterIdentify(commands);
8641     registerClusterLevelControl(commands);
8642     registerClusterLowPower(commands);
8643     registerClusterOnOff(commands);
8644     registerClusterScenes(commands);
8645     registerClusterTemperatureMeasurement(commands);
8646 }