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