examples/chip-tool/gen/client-command-macro.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 // Prevent multiple inclusion
  21 #pragma once
  22
  23 /** @brief Command description for ReadAttributes
  24  *
  25  * Command: ReadAttributes
  26  * @param attributeIds ATTRIBUTE_ID []
  27  * @param attributeIdsLen int
  28  */
  29 #define emberAfFillCommandGlobalReadAttributes(clusterId, attributeIds, attributeIdsLen)                                           \
  30     emberAfFillExternalBuffer(mask, clusterId, ZCL_READ_ATTRIBUTES_COMMAND_ID, "b", attributeIds, attributeIdsLen);
  31
  32 /** @brief Command description for ReadAttributesResponse
  33  *
  34  * Command: ReadAttributesResponse
  35  * @param readAttributeStatusRecords ReadAttributeStatusRecord []
  36  * @param readAttributeStatusRecordsLen int
  37  */
  38 #define emberAfFillCommandGlobalReadAttributesResponse(clusterId, readAttributeStatusRecords, readAttributeStatusRecordsLen)       \
  39     emberAfFillExternalBuffer(mask, clusterId, ZCL_READ_ATTRIBUTES_RESPONSE_COMMAND_ID, "b", readAttributeStatusRecords,           \
  40                               readAttributeStatusRecordsLen);
  41
  42 /** @brief Command description for WriteAttributes
  43  *
  44  * Command: WriteAttributes
  45  * @param writeAttributeRecords WriteAttributeRecord []
  46  * @param writeAttributeRecordsLen int
  47  */
  48 #define emberAfFillCommandGlobalWriteAttributes(clusterId, writeAttributeRecords, writeAttributeRecordsLen)                        \
  49     emberAfFillExternalBuffer(mask, clusterId, ZCL_WRITE_ATTRIBUTES_COMMAND_ID, "b", writeAttributeRecords,                        \
  50                               writeAttributeRecordsLen);
  51
  52 /** @brief Command description for WriteAttributesUndivided
  53  *
  54  * Command: WriteAttributesUndivided
  55  * @param writeAttributeRecords WriteAttributeRecord []
  56  * @param writeAttributeRecordsLen int
  57  */
  58 #define emberAfFillCommandGlobalWriteAttributesUndivided(clusterId, writeAttributeRecords, writeAttributeRecordsLen)               \
  59     emberAfFillExternalBuffer(mask, clusterId, ZCL_WRITE_ATTRIBUTES_UNDIVIDED_COMMAND_ID, "b", writeAttributeRecords,              \
  60                               writeAttributeRecordsLen);
  61
  62 /** @brief Command description for WriteAttributesResponse
  63  *
  64  * Command: WriteAttributesResponse
  65  * @param writeAttributeStatusRecords WriteAttributeStatusRecord []
  66  * @param writeAttributeStatusRecordsLen int
  67  */
  68 #define emberAfFillCommandGlobalWriteAttributesResponse(clusterId, writeAttributeStatusRecords, writeAttributeStatusRecordsLen)    \
  69     emberAfFillExternalBuffer(mask, clusterId, ZCL_WRITE_ATTRIBUTES_RESPONSE_COMMAND_ID, "b", writeAttributeStatusRecords,         \
  70                               writeAttributeStatusRecordsLen);
  71
  72 /** @brief Command description for WriteAttributesNoResponse
  73  *
  74  * Command: WriteAttributesNoResponse
  75  * @param writeAttributeRecords WriteAttributeRecord []
  76  * @param writeAttributeRecordsLen int
  77  */
  78 #define emberAfFillCommandGlobalWriteAttributesNoResponse(clusterId, writeAttributeRecords, writeAttributeRecordsLen)              \
  79     emberAfFillExternalBuffer(mask, clusterId, ZCL_WRITE_ATTRIBUTES_NO_RESPONSE_COMMAND_ID, "b", writeAttributeRecords,            \
  80                               writeAttributeRecordsLen);
  81
  82 /** @brief Command description for ConfigureReporting
  83  *
  84  * Command: ConfigureReporting
  85  * @param configureReportingRecords ConfigureReportingRecord []
  86  * @param configureReportingRecordsLen int
  87  */
  88 #define emberAfFillCommandGlobalConfigureReporting(clusterId, configureReportingRecords, configureReportingRecordsLen)             \
  89     emberAfFillExternalBuffer(mask, clusterId, ZCL_CONFIGURE_REPORTING_COMMAND_ID, "b", configureReportingRecords,                 \
  90                               configureReportingRecordsLen);
  91
  92 /** @brief Command description for ConfigureReportingResponse
  93  *
  94  * Command: ConfigureReportingResponse
  95  * @param configureReportingStatusRecords ConfigureReportingStatusRecord []
  96  * @param configureReportingStatusRecordsLen int
  97  */
  98 #define emberAfFillCommandGlobalConfigureReportingResponse(clusterId, configureReportingStatusRecords,                             \
  99                                                            configureReportingStatusRecordsLen)                                     \
 100     emberAfFillExternalBuffer(mask, clusterId, ZCL_CONFIGURE_REPORTING_RESPONSE_COMMAND_ID, "b", configureReportingStatusRecords,  \
 101                               configureReportingStatusRecordsLen);
 102
 103 /** @brief Command description for ReadReportingConfiguration
 104  *
 105  * Command: ReadReportingConfiguration
 106  * @param readReportingConfigurationAttributeRecords ReadReportingConfigurationAttributeRecord []
 107  * @param readReportingConfigurationAttributeRecordsLen int
 108  */
 109 #define emberAfFillCommandGlobalReadReportingConfiguration(clusterId, readReportingConfigurationAttributeRecords,                  \
 110                                                            readReportingConfigurationAttributeRecordsLen)                          \
 111     emberAfFillExternalBuffer(mask, clusterId, ZCL_READ_REPORTING_CONFIGURATION_COMMAND_ID, "b",                                   \
 112                               readReportingConfigurationAttributeRecords, readReportingConfigurationAttributeRecordsLen);
 113
 114 /** @brief Command description for ReadReportingConfigurationResponse
 115  *
 116  * Command: ReadReportingConfigurationResponse
 117  * @param readReportingConfigurationRecords ReadReportingConfigurationRecord []
 118  * @param readReportingConfigurationRecordsLen int
 119  */
 120 #define emberAfFillCommandGlobalReadReportingConfigurationResponse(clusterId, readReportingConfigurationRecords,                   \
 121                                                                    readReportingConfigurationRecordsLen)                           \
 122     emberAfFillExternalBuffer(mask, clusterId, ZCL_READ_REPORTING_CONFIGURATION_RESPONSE_COMMAND_ID, "b",                          \
 123                               readReportingConfigurationRecords, readReportingConfigurationRecordsLen);
 124
 125 /** @brief Command description for ReportAttributes
 126  *
 127  * Command: ReportAttributes
 128  * @param reportAttributeRecords ReportAttributeRecord []
 129  * @param reportAttributeRecordsLen int
 130  */
 131 #define emberAfFillCommandGlobalReportAttributes(clusterId, reportAttributeRecords, reportAttributeRecordsLen)                     \
 132     emberAfFillExternalBuffer(mask, clusterId, ZCL_REPORT_ATTRIBUTES_COMMAND_ID, "b", reportAttributeRecords,                      \
 133                               reportAttributeRecordsLen);
 134
 135 /** @brief Command description for DefaultResponse
 136  *
 137  * Command: DefaultResponse
 138  * @param commandId INT8U
 139  * @param status Status
 140  */
 141 #define emberAfFillCommandGlobalDefaultResponse(clusterId, commandId, status)                                                      \
 142     emberAfFillExternalBuffer(mask, clusterId, ZCL_DEFAULT_RESPONSE_COMMAND_ID, "uu", commandId, status);
 143
 144 /** @brief Command description for DiscoverAttributes
 145  *
 146  * Command: DiscoverAttributes
 147  * @param startId ATTRIBUTE_ID
 148  * @param maxAttributeIds INT8U
 149  */
 150 #define emberAfFillCommandGlobalDiscoverAttributes(clusterId, startId, maxAttributeIds)                                            \
 151     emberAfFillExternalBuffer(mask, clusterId, ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID, "uu", startId, maxAttributeIds);
 152
 153 /** @brief Command description for DiscoverAttributesResponse
 154  *
 155  * Command: DiscoverAttributesResponse
 156  * @param discoveryComplete INT8U
 157  * @param discoverAttributesInfoRecords DiscoverAttributesInfoRecord []
 158  * @param discoverAttributesInfoRecordsLen int
 159  */
 160 #define emberAfFillCommandGlobalDiscoverAttributesResponse(clusterId, discoveryComplete, discoverAttributesInfoRecords,            \
 161                                                            discoverAttributesInfoRecordsLen)                                       \
 162     emberAfFillExternalBuffer(mask, clusterId, ZCL_DISCOVER_ATTRIBUTES_RESPONSE_COMMAND_ID, "ub", discoveryComplete,               \
 163                               discoverAttributesInfoRecords, discoverAttributesInfoRecordsLen);
 164
 165 /** @brief Command description for ReadAttributesStructured
 166  *
 167  * Command: ReadAttributesStructured
 168  * @param readStructuredAttributeRecords ReadStructuredAttributeRecord []
 169  * @param readStructuredAttributeRecordsLen int
 170  */
 171 #define emberAfFillCommandGlobalReadAttributesStructured(clusterId, readStructuredAttributeRecords,                                \
 172                                                          readStructuredAttributeRecordsLen)                                        \
 173     emberAfFillExternalBuffer(mask, clusterId, ZCL_READ_ATTRIBUTES_STRUCTURED_COMMAND_ID, "b", readStructuredAttributeRecords,     \
 174                               readStructuredAttributeRecordsLen);
 175
 176 /** @brief Command description for WriteAttributesStructured
 177  *
 178  * Command: WriteAttributesStructured
 179  * @param writeStructuredAttributeRecords WriteStructuredAttributeRecord []
 180  * @param writeStructuredAttributeRecordsLen int
 181  */
 182 #define emberAfFillCommandGlobalWriteAttributesStructured(clusterId, writeStructuredAttributeRecords,                              \
 183                                                           writeStructuredAttributeRecordsLen)                                      \
 184     emberAfFillExternalBuffer(mask, clusterId, ZCL_WRITE_ATTRIBUTES_STRUCTURED_COMMAND_ID, "b", writeStructuredAttributeRecords,   \
 185                               writeStructuredAttributeRecordsLen);
 186
 187 /** @brief Command description for WriteAttributesStructuredResponse
 188  *
 189  * Command: WriteAttributesStructuredResponse
 190  * @param writeStructuredAttributeStatusRecords WriteStructuredAttributeStatusRecord []
 191  * @param writeStructuredAttributeStatusRecordsLen int
 192  */
 193 #define emberAfFillCommandGlobalWriteAttributesStructuredResponse(clusterId, writeStructuredAttributeStatusRecords,                \
 194                                                                   writeStructuredAttributeStatusRecordsLen)                        \
 195     emberAfFillExternalBuffer(mask, clusterId, ZCL_WRITE_ATTRIBUTES_STRUCTURED_RESPONSE_COMMAND_ID, "b",                           \
 196                               writeStructuredAttributeStatusRecords, writeStructuredAttributeStatusRecordsLen);
 197
 198 /** @brief Command description for DiscoverCommandsReceived
 199  *
 200  * Command: DiscoverCommandsReceived
 201  * @param startCommandId INT8U
 202  * @param maxCommandIds INT8U
 203  */
 204 #define emberAfFillCommandGlobalDiscoverCommandsReceived(clusterId, startCommandId, maxCommandIds)                                 \
 205     emberAfFillExternalBuffer(mask, clusterId, ZCL_DISCOVER_COMMANDS_RECEIVED_COMMAND_ID, "uu", startCommandId, maxCommandIds);
 206
 207 /** @brief Command description for DiscoverCommandsReceivedResponse
 208  *
 209  * Command: DiscoverCommandsReceivedResponse
 210  * @param discoveryComplete INT8U
 211  * @param commandIds INT8U []
 212  * @param commandIdsLen int
 213  */
 214 #define emberAfFillCommandGlobalDiscoverCommandsReceivedResponse(clusterId, discoveryComplete, commandIds, commandIdsLen)          \
 215     emberAfFillExternalBuffer(mask, clusterId, ZCL_DISCOVER_COMMANDS_RECEIVED_RESPONSE_COMMAND_ID, "ub", discoveryComplete,        \
 216                               commandIds, commandIdsLen);
 217
 218 /** @brief Command description for DiscoverCommandsGenerated
 219  *
 220  * Command: DiscoverCommandsGenerated
 221  * @param startCommandId INT8U
 222  * @param maxCommandIds INT8U
 223  */
 224 #define emberAfFillCommandGlobalDiscoverCommandsGenerated(clusterId, startCommandId, maxCommandIds)                                \
 225     emberAfFillExternalBuffer(mask, clusterId, ZCL_DISCOVER_COMMANDS_GENERATED_COMMAND_ID, "uu", startCommandId, maxCommandIds);
 226
 227 /** @brief Command description for DiscoverCommandsGeneratedResponse
 228  *
 229  * Command: DiscoverCommandsGeneratedResponse
 230  * @param discoveryComplete INT8U
 231  * @param commandIds INT8U []
 232  * @param commandIdsLen int
 233  */
 234 #define emberAfFillCommandGlobalDiscoverCommandsGeneratedResponse(clusterId, discoveryComplete, commandIds, commandIdsLen)         \
 235     emberAfFillExternalBuffer(mask, clusterId, ZCL_DISCOVER_COMMANDS_GENERATED_RESPONSE_COMMAND_ID, "ub", discoveryComplete,       \
 236                               commandIds, commandIdsLen);
 237
 238 /** @brief Command description for DiscoverAttributesExtended
 239  *
 240  * Command: DiscoverAttributesExtended
 241  * @param startId ATTRIBUTE_ID
 242  * @param maxAttributeIds INT8U
 243  */
 244 #define emberAfFillCommandGlobalDiscoverAttributesExtended(clusterId, startId, maxAttributeIds)                                    \
 245     emberAfFillExternalBuffer(mask, clusterId, ZCL_DISCOVER_ATTRIBUTES_EXTENDED_COMMAND_ID, "uu", startId, maxAttributeIds);
 246
 247 /** @brief Command description for DiscoverAttributesExtendedResponse
 248  *
 249  * Command: DiscoverAttributesExtendedResponse
 250  * @param discoveryComplete INT8U
 251  * @param extendedDiscoverAttributesInfoRecords ExtendedDiscoverAttributesInfoRecord []
 252  * @param extendedDiscoverAttributesInfoRecordsLen int
 253  */
 254 #define emberAfFillCommandGlobalDiscoverAttributesExtendedResponse(                                                                \
 255     clusterId, discoveryComplete, extendedDiscoverAttributesInfoRecords, extendedDiscoverAttributesInfoRecordsLen)                 \
 256     emberAfFillExternalBuffer(mask, clusterId, ZCL_DISCOVER_ATTRIBUTES_EXTENDED_RESPONSE_COMMAND_ID, "ub", discoveryComplete,      \
 257                               extendedDiscoverAttributesInfoRecords, extendedDiscoverAttributesInfoRecordsLen);
 258
 259 /** @brief Command description for Identify
 260  *
 261  * Command: Identify
 262  * @param identifyTime INT16U
 263  * @param timeout INT16U
 264  */
 265 #define emberAfFillCommandIdentifyClusterIdentify(identifyTime, timeout)                                                           \
 266     emberAfFillExternalBuffer(mask,                                                                                                \
 267                                                                                                                                    \
 268                               ZCL_IDENTIFY_COMMAND_ID, "uu", identifyTime, timeout);
 269
 270 /** @brief Command description for IdentifyQuery
 271  *
 272  * Command: IdentifyQuery
 273  */
 274 #define emberAfFillCommandIdentifyClusterIdentifyQuery()                                                                           \
 275     emberAfFillExternalBuffer(mask,                                                                                                \
 276                                                                                                                                    \
 277                               ZCL_IDENTIFY_QUERY_COMMAND_ID, "", );
 278
 279 /** @brief Command description for EZModeInvoke
 280  *
 281  * Command: EZModeInvoke
 282  * @param action BITMAP8
 283  */
 284 #define emberAfFillCommandIdentifyClusterEZModeInvoke(action)                                                                      \
 285     emberAfFillExternalBuffer(mask,                                                                                                \
 286                                                                                                                                    \
 287                               ZCL_EZ_MODE_INVOKE_COMMAND_ID, "u", action);
 288
 289 /** @brief Command description for UpdateCommissionState
 290  *
 291  * Command: UpdateCommissionState
 292  * @param action ENUM8
 293  * @param commissionStateMask BITMAP8
 294  */
 295 #define emberAfFillCommandIdentifyClusterUpdateCommissionState(action, commissionStateMask)                                        \
 296     emberAfFillExternalBuffer(mask,                                                                                                \
 297                                                                                                                                    \
 298                               ZCL_UPDATE_COMMISSION_STATE_COMMAND_ID, "uu", action, commissionStateMask);
 299
 300 /** @brief Command description for TriggerEffect
 301  *
 302  * Command: TriggerEffect
 303  * @param effectId IdentifyEffectIdentifier
 304  * @param effectVariant IdentifyEffectVariant
 305  */
 306 #define emberAfFillCommandIdentifyClusterTriggerEffect(effectId, effectVariant)                                                    \
 307     emberAfFillExternalBuffer(mask,                                                                                                \
 308                                                                                                                                    \
 309                               ZCL_TRIGGER_EFFECT_COMMAND_ID, "uu", effectId, effectVariant);
 310
 311 /** @brief Command description for AddGroup
 312  *
 313  * Command: AddGroup
 314  * @param groupId INT16U
 315  * @param status Status
 316  * @param groupName CHAR_STRING
 317  * @param groupId INT16U
 318  */
 319 #define emberAfFillCommandGroupsClusterAddGroup(groupId, status, groupName, groupId)                                               \
 320     emberAfFillExternalBuffer(mask,                                                                                                \
 321                                                                                                                                    \
 322                               ZCL_ADD_GROUP_COMMAND_ID, "uuuu", groupId, status, groupName, groupId);
 323
 324 /** @brief Command description for ViewGroup
 325  *
 326  * Command: ViewGroup
 327  * @param groupId INT16U
 328  * @param status Status
 329  * @param groupId INT16U
 330  * @param groupName CHAR_STRING
 331  */
 332 #define emberAfFillCommandGroupsClusterViewGroup(groupId, status, groupId, groupName)                                              \
 333     emberAfFillExternalBuffer(mask,                                                                                                \
 334                                                                                                                                    \
 335                               ZCL_VIEW_GROUP_COMMAND_ID, "uuuu", groupId, status, groupId, groupName);
 336
 337 /** @brief Command description for GetGroupMembership
 338  *
 339  * Command: GetGroupMembership
 340  * @param groupCount INT8U
 341  * @param capacity INT8U
 342  * @param groupList INT16U []
 343  * @param groupListLen int
 344  * @param groupCount INT8U
 345  * @param groupList INT16U []
 346  * @param groupListLen int
 347  */
 348 #define emberAfFillCommandGroupsClusterGetGroupMembership(groupCount, capacity, groupList, groupListLen, groupCount, groupList,    \
 349                                                           groupListLen)                                                            \
 350     emberAfFillExternalBuffer(mask,                                                                                                \
 351                                                                                                                                    \
 352                               ZCL_GET_GROUP_MEMBERSHIP_COMMAND_ID, "uubub", groupCount, capacity, groupList, groupListLen,         \
 353                               groupCount, groupList, groupListLen);
 354
 355 /** @brief Command description for RemoveGroup
 356  *
 357  * Command: RemoveGroup
 358  * @param groupId INT16U
 359  * @param status Status
 360  * @param groupId INT16U
 361  */
 362 #define emberAfFillCommandGroupsClusterRemoveGroup(groupId, status, groupId)                                                       \
 363     emberAfFillExternalBuffer(mask,                                                                                                \
 364                                                                                                                                    \
 365                               ZCL_REMOVE_GROUP_COMMAND_ID, "uuu", groupId, status, groupId);
 366
 367 /** @brief Command description for RemoveAllGroups
 368  *
 369  * Command: RemoveAllGroups
 370  */
 371 #define emberAfFillCommandGroupsClusterRemoveAllGroups()                                                                           \
 372     emberAfFillExternalBuffer(mask,                                                                                                \
 373                                                                                                                                    \
 374                               ZCL_REMOVE_ALL_GROUPS_COMMAND_ID, "", );
 375
 376 /** @brief Command description for AddGroupIfIdentifying
 377  *
 378  * Command: AddGroupIfIdentifying
 379  * @param groupId INT16U
 380  * @param groupName CHAR_STRING
 381  */
 382 #define emberAfFillCommandGroupsClusterAddGroupIfIdentifying(groupId, groupName)                                                   \
 383     emberAfFillExternalBuffer(mask,                                                                                                \
 384                                                                                                                                    \
 385                               ZCL_ADD_GROUP_IF_IDENTIFYING_COMMAND_ID, "uu", groupId, groupName);
 386
 387 /** @brief Command description for AddScene
 388  *
 389  * Command: AddScene
 390  * @param groupId INT16U
 391  * @param status Status
 392  * @param sceneId INT8U
 393  * @param groupId INT16U
 394  * @param transitionTime INT16U
 395  * @param sceneId INT8U
 396  * @param sceneName CHAR_STRING
 397  * @param extensionFieldSets SceneExtensionFieldSet []
 398  * @param extensionFieldSetsLen int
 399  */
 400 #define emberAfFillCommandScenesClusterAddScene(groupId, status, sceneId, groupId, transitionTime, sceneId, sceneName,             \
 401                                                 extensionFieldSets, extensionFieldSetsLen)                                         \
 402     emberAfFillExternalBuffer(mask,                                                                                                \
 403                                                                                                                                    \
 404                               ZCL_ADD_SCENE_COMMAND_ID, "uuuuuuub", groupId, status, sceneId, groupId, transitionTime, sceneId,    \
 405                               sceneName, extensionFieldSets, extensionFieldSetsLen);
 406
 407 /** @brief Command description for ViewScene
 408  *
 409  * Command: ViewScene
 410  * @param groupId INT16U
 411  * @param status Status
 412  * @param sceneId INT8U
 413  * @param groupId INT16U
 414  * @param sceneId INT8U
 415  * @param transitionTime INT16U
 416  * @param sceneName CHAR_STRING
 417  * @param extensionFieldSets SceneExtensionFieldSet []
 418  * @param extensionFieldSetsLen int
 419  */
 420 #define emberAfFillCommandScenesClusterViewScene(groupId, status, sceneId, groupId, sceneId, transitionTime, sceneName,            \
 421                                                  extensionFieldSets, extensionFieldSetsLen)                                        \
 422     emberAfFillExternalBuffer(mask,                                                                                                \
 423                                                                                                                                    \
 424                               ZCL_VIEW_SCENE_COMMAND_ID, "uuuuuuub", groupId, status, sceneId, groupId, sceneId, transitionTime,   \
 425                               sceneName, extensionFieldSets, extensionFieldSetsLen);
 426
 427 /** @brief Command description for RemoveScene
 428  *
 429  * Command: RemoveScene
 430  * @param groupId INT16U
 431  * @param status Status
 432  * @param sceneId INT8U
 433  * @param groupId INT16U
 434  * @param sceneId INT8U
 435  */
 436 #define emberAfFillCommandScenesClusterRemoveScene(groupId, status, sceneId, groupId, sceneId)                                     \
 437     emberAfFillExternalBuffer(mask,                                                                                                \
 438                                                                                                                                    \
 439                               ZCL_REMOVE_SCENE_COMMAND_ID, "uuuuu", groupId, status, sceneId, groupId, sceneId);
 440
 441 /** @brief Command description for RemoveAllScenes
 442  *
 443  * Command: RemoveAllScenes
 444  * @param groupId INT16U
 445  * @param status Status
 446  * @param groupId INT16U
 447  */
 448 #define emberAfFillCommandScenesClusterRemoveAllScenes(groupId, status, groupId)                                                   \
 449     emberAfFillExternalBuffer(mask,                                                                                                \
 450                                                                                                                                    \
 451                               ZCL_REMOVE_ALL_SCENES_COMMAND_ID, "uuu", groupId, status, groupId);
 452
 453 /** @brief Command description for StoreScene
 454  *
 455  * Command: StoreScene
 456  * @param groupId INT16U
 457  * @param status Status
 458  * @param sceneId INT8U
 459  * @param groupId INT16U
 460  * @param sceneId INT8U
 461  */
 462 #define emberAfFillCommandScenesClusterStoreScene(groupId, status, sceneId, groupId, sceneId)                                      \
 463     emberAfFillExternalBuffer(mask,                                                                                                \
 464                                                                                                                                    \
 465                               ZCL_STORE_SCENE_COMMAND_ID, "uuuuu", groupId, status, sceneId, groupId, sceneId);
 466
 467 /** @brief Command description for RecallScene
 468  *
 469  * Command: RecallScene
 470  * @param groupId INT16U
 471  * @param sceneId INT8U
 472  * @param transitionTime INT16U
 473  */
 474 #define emberAfFillCommandScenesClusterRecallScene(groupId, sceneId, transitionTime)                                               \
 475     emberAfFillExternalBuffer(mask,                                                                                                \
 476                                                                                                                                    \
 477                               ZCL_RECALL_SCENE_COMMAND_ID, "uuu", groupId, sceneId, transitionTime);
 478
 479 /** @brief Command description for GetSceneMembership
 480  *
 481  * Command: GetSceneMembership
 482  * @param groupId INT16U
 483  * @param status Status
 484  * @param capacity INT8U
 485  * @param groupId INT16U
 486  * @param sceneCount INT8U
 487  * @param sceneList INT8U []
 488  * @param sceneListLen int
 489  */
 490 #define emberAfFillCommandScenesClusterGetSceneMembership(groupId, status, capacity, groupId, sceneCount, sceneList, sceneListLen) \
 491     emberAfFillExternalBuffer(mask,                                                                                                \
 492                                                                                                                                    \
 493                               ZCL_GET_SCENE_MEMBERSHIP_COMMAND_ID, "uuuuub", groupId, status, capacity, groupId, sceneCount,       \
 494                               sceneList, sceneListLen);
 495
 496 /** @brief Command description for EnhancedAddScene
 497  *
 498  * Command: EnhancedAddScene
 499  * @param groupId INT16U
 500  * @param status Status
 501  * @param sceneId INT8U
 502  * @param groupId INT16U
 503  * @param transitionTime INT16U
 504  * @param sceneId INT8U
 505  * @param sceneName CHAR_STRING
 506  * @param extensionFieldSets SceneExtensionFieldSet []
 507  * @param extensionFieldSetsLen int
 508  */
 509 #define emberAfFillCommandScenesClusterEnhancedAddScene(groupId, status, sceneId, groupId, transitionTime, sceneId, sceneName,     \
 510                                                         extensionFieldSets, extensionFieldSetsLen)                                 \
 511     emberAfFillExternalBuffer(mask,                                                                                                \
 512                                                                                                                                    \
 513                               ZCL_ENHANCED_ADD_SCENE_COMMAND_ID, "uuuuuuub", groupId, status, sceneId, groupId, transitionTime,    \
 514                               sceneId, sceneName, extensionFieldSets, extensionFieldSetsLen);
 515
 516 /** @brief Command description for EnhancedViewScene
 517  *
 518  * Command: EnhancedViewScene
 519  * @param groupId INT16U
 520  * @param status Status
 521  * @param sceneId INT8U
 522  * @param groupId INT16U
 523  * @param sceneId INT8U
 524  * @param transitionTime INT16U
 525  * @param sceneName CHAR_STRING
 526  * @param extensionFieldSets SceneExtensionFieldSet []
 527  * @param extensionFieldSetsLen int
 528  */
 529 #define emberAfFillCommandScenesClusterEnhancedViewScene(groupId, status, sceneId, groupId, sceneId, transitionTime, sceneName,    \
 530                                                          extensionFieldSets, extensionFieldSetsLen)                                \
 531     emberAfFillExternalBuffer(mask,                                                                                                \
 532                                                                                                                                    \
 533                               ZCL_ENHANCED_VIEW_SCENE_COMMAND_ID, "uuuuuuub", groupId, status, sceneId, groupId, sceneId,          \
 534                               transitionTime, sceneName, extensionFieldSets, extensionFieldSetsLen);
 535
 536 /** @brief Command description for CopyScene
 537  *
 538  * Command: CopyScene
 539  * @param mode ScenesCopyMode
 540  * @param status Status
 541  * @param groupIdFrom INT16U
 542  * @param groupIdFrom INT16U
 543  * @param sceneIdFrom INT8U
 544  * @param sceneIdFrom INT8U
 545  * @param groupIdTo INT16U
 546  * @param sceneIdTo INT8U
 547  */
 548 #define emberAfFillCommandScenesClusterCopyScene(mode, status, groupIdFrom, groupIdFrom, sceneIdFrom, sceneIdFrom, groupIdTo,      \
 549                                                  sceneIdTo)                                                                        \
 550     emberAfFillExternalBuffer(mask,                                                                                                \
 551                                                                                                                                    \
 552                               ZCL_COPY_SCENE_COMMAND_ID, "uuuuuuuu", mode, status, groupIdFrom, groupIdFrom, sceneIdFrom,          \
 553                               sceneIdFrom, groupIdTo, sceneIdTo);
 554
 555 /** @brief Command description for Off
 556  *
 557  * Command: Off
 558  */
 559 #define emberAfFillCommandOn                                                                                                       \
 560     /                                                                                                                              \
 561         offClusterOff() emberAfFillExternalBuffer(mask,                                                                            \
 562                                                                                                                                    \
 563                                                   ZCL_OFF_COMMAND_ID, "", );
 564
 565 /** @brief Command description for On
 566  *
 567  * Command: On
 568  */
 569 #define emberAfFillCommandOn                                                                                                       \
 570     /                                                                                                                              \
 571         offClusterOn() emberAfFillExternalBuffer(mask,                                                                             \
 572                                                                                                                                    \
 573                                                  ZCL_ON_COMMAND_ID, "", );
 574
 575 /** @brief Command description for Toggle
 576  *
 577  * Command: Toggle
 578  */
 579 #define emberAfFillCommandOn                                                                                                       \
 580     /                                                                                                                              \
 581         offClusterToggle() emberAfFillExternalBuffer(mask,                                                                         \
 582                                                                                                                                    \
 583                                                      ZCL_TOGGLE_COMMAND_ID, "", );
 584
 585 /** @brief Command description for OffWithEffect
 586  *
 587  * Command: OffWithEffect
 588  * @param effectId OnOffEffectIdentifier
 589  * @param effectVariant ENUM8
 590  */
 591 #define emberAfFillCommandOn                                                                                                       \
 592     /                                                                                                                              \
 593         offClusterOffWithEffect(effectId, effectVariant)                                                                           \
 594             emberAfFillExternalBuffer(mask,                                                                                        \
 595                                                                                                                                    \
 596                                       ZCL_OFF_WITH_EFFECT_COMMAND_ID, "uu", effectId, effectVariant);
 597
 598 /** @brief Command description for OnWithRecallGlobalScene
 599  *
 600  * Command: OnWithRecallGlobalScene
 601  */
 602 #define emberAfFillCommandOn                                                                                                       \
 603     /                                                                                                                              \
 604         offClusterOnWithRecallGlobalScene() emberAfFillExternalBuffer(mask,                                                        \
 605                                                                                                                                    \
 606                                                                       ZCL_ON_WITH_RECALL_GLOBAL_SCENE_COMMAND_ID, "", );
 607
 608 /** @brief Command description for OnWithTimedOff
 609  *
 610  * Command: OnWithTimedOff
 611  * @param onOffControl OnOffControl
 612  * @param onTime INT16U
 613  * @param offWaitTime INT16U
 614  */
 615 #define emberAfFillCommandOn                                                                                                       \
 616     /                                                                                                                              \
 617         offClusterOnWithTimedOff(onOffControl, onTime, offWaitTime)                                                                \
 618             emberAfFillExternalBuffer(mask,                                                                                        \
 619                                                                                                                                    \
 620                                       ZCL_ON_WITH_TIMED_OFF_COMMAND_ID, "uuu", onOffControl, onTime, offWaitTime);
 621
 622 /** @brief Command description for MoveToLevel
 623  *
 624  * Command: MoveToLevel
 625  * @param level INT8U
 626  * @param transitionTime INT16U
 627  * @param optionMask BITMAP8
 628  * @param optionOverride BITMAP8
 629  */
 630 #define emberAfFillCommandLevel                                                                                                    \
 631     ControlClusterMoveToLevel(level, transitionTime, optionMask, optionOverride)                                                   \
 632         emberAfFillExternalBuffer(mask,                                                                                            \
 633                                                                                                                                    \
 634                                   ZCL_MOVE_TO_LEVEL_COMMAND_ID, "uuuu", level, transitionTime, optionMask, optionOverride);
 635
 636 /** @brief Command description for Move
 637  *
 638  * Command: Move
 639  * @param moveMode MoveMode
 640  * @param rate INT8U
 641  * @param optionMask BITMAP8
 642  * @param optionOverride BITMAP8
 643  */
 644 #define emberAfFillCommandLevel                                                                                                    \
 645     ControlClusterMove(moveMode, rate, optionMask, optionOverride)                                                                 \
 646         emberAfFillExternalBuffer(mask,                                                                                            \
 647                                                                                                                                    \
 648                                   ZCL_MOVE_COMMAND_ID, "uuuu", moveMode, rate, optionMask, optionOverride);
 649
 650 /** @brief Command description for Step
 651  *
 652  * Command: Step
 653  * @param stepMode StepMode
 654  * @param stepSize INT8U
 655  * @param transitionTime INT16U
 656  * @param optionMask BITMAP8
 657  * @param optionOverride BITMAP8
 658  */
 659 #define emberAfFillCommandLevel                                                                                                    \
 660     ControlClusterStep(stepMode, stepSize, transitionTime, optionMask, optionOverride)                                             \
 661         emberAfFillExternalBuffer(mask,                                                                                            \
 662                                                                                                                                    \
 663                                   ZCL_STEP_COMMAND_ID, "uuuuu", stepMode, stepSize, transitionTime, optionMask, optionOverride);
 664
 665 /** @brief Command description for Stop
 666  *
 667  * Command: Stop
 668  * @param optionMask BITMAP8
 669  * @param optionOverride BITMAP8
 670  */
 671 #define emberAfFillCommandLevel                                                                                                    \
 672     ControlClusterStop(optionMask, optionOverride)                                                                                 \
 673         emberAfFillExternalBuffer(mask,                                                                                            \
 674                                                                                                                                    \
 675                                   ZCL_STOP_COMMAND_ID, "uu", optionMask, optionOverride);
 676
 677 /** @brief Command description for MoveToLevelWithOnOff
 678  *
 679  * Command: MoveToLevelWithOnOff
 680  * @param level INT8U
 681  * @param transitionTime INT16U
 682  */
 683 #define emberAfFillCommandLevel                                                                                                    \
 684     ControlClusterMoveToLevelWithOnOff(level, transitionTime)                                                                      \
 685         emberAfFillExternalBuffer(mask,                                                                                            \
 686                                                                                                                                    \
 687                                   ZCL_MOVE_TO_LEVEL_WITH_ON_OFF_COMMAND_ID, "uu", level, transitionTime);
 688
 689 /** @brief Command description for MoveWithOnOff
 690  *
 691  * Command: MoveWithOnOff
 692  * @param moveMode MoveMode
 693  * @param rate INT8U
 694  */
 695 #define emberAfFillCommandLevel                                                                                                    \
 696     ControlClusterMoveWithOnOff(moveMode, rate) emberAfFillExternalBuffer(mask,                                                    \
 697                                                                                                                                    \
 698                                                                           ZCL_MOVE_WITH_ON_OFF_COMMAND_ID, "uu", moveMode, rate);
 699
 700 /** @brief Command description for StepWithOnOff
 701  *
 702  * Command: StepWithOnOff
 703  * @param stepMode StepMode
 704  * @param stepSize INT8U
 705  * @param transitionTime INT16U
 706  */
 707 #define emberAfFillCommandLevel                                                                                                    \
 708     ControlClusterStepWithOnOff(stepMode, stepSize, transitionTime)                                                                \
 709         emberAfFillExternalBuffer(mask,                                                                                            \
 710                                                                                                                                    \
 711                                   ZCL_STEP_WITH_ON_OFF_COMMAND_ID, "uuu", stepMode, stepSize, transitionTime);
 712
 713 /** @brief Command description for StopWithOnOff
 714  *
 715  * Command: StopWithOnOff
 716  */
 717 #define emberAfFillCommandLevel                                                                                                    \
 718     ControlClusterStopWithOnOff() emberAfFillExternalBuffer(mask,                                                                  \
 719                                                                                                                                    \
 720                                                             ZCL_STOP_WITH_ON_OFF_COMMAND_ID, "", );
 721
 722 /** @brief Command description for ResetAlarm
 723  *
 724  * Command: ResetAlarm
 725  * @param alarmCode ENUM8
 726  * @param alarmCode ENUM8
 727  * @param clusterId CLUSTER_ID
 728  * @param clusterId CLUSTER_ID
 729  */
 730 #define emberAfFillCommandAlarmsClusterResetAlarm(alarmCode, alarmCode, clusterId, clusterId)                                      \
 731     emberAfFillExternalBuffer(mask,                                                                                                \
 732                                                                                                                                    \
 733                               ZCL_RESET_ALARM_COMMAND_ID, "uuuu", alarmCode, alarmCode, clusterId, clusterId);
 734
 735 /** @brief Command description for ResetAllAlarms
 736  *
 737  * Command: ResetAllAlarms
 738  * @param status Status
 739  * @param alarmCode ENUM8
 740  * @param clusterId CLUSTER_ID
 741  * @param timeStamp INT32U
 742  */
 743 #define emberAfFillCommandAlarmsClusterResetAllAlarms(status, alarmCode, clusterId, timeStamp)                                     \
 744     emberAfFillExternalBuffer(mask,                                                                                                \
 745                                                                                                                                    \
 746                               ZCL_RESET_ALL_ALARMS_COMMAND_ID, "uuuu", status, alarmCode, clusterId, timeStamp);
 747
 748 /** @brief Command description for GetAlarm
 749  *
 750  * Command: GetAlarm
 751  */
 752 #define emberAfFillCommandAlarmsClusterGetAlarm()                                                                                  \
 753     emberAfFillExternalBuffer(mask,                                                                                                \
 754                                                                                                                                    \
 755                               ZCL_GET_ALARM_COMMAND_ID, "", );
 756
 757 /** @brief Command description for ResetAlarmLog
 758  *
 759  * Command: ResetAlarmLog
 760  */
 761 #define emberAfFillCommandAlarmsClusterResetAlarmLog()                                                                             \
 762     emberAfFillExternalBuffer(mask,                                                                                                \
 763                                                                                                                                    \
 764                               ZCL_RESET_ALARM_LOG_COMMAND_ID, "", );
 765
 766 /** @brief Command description for SetAbsoluteLocation
 767  *
 768  * Command: SetAbsoluteLocation
 769  * @param coordinate1 INT16S
 770  * @param status Status
 771  * @param coordinate2 INT16S
 772  * @param power INT16S
 773  * @param coordinate3 INT16S
 774  * @param pathLossExponent INT16U
 775  * @param power INT16S
 776  * @param calculationPeriod INT16U
 777  * @param pathLossExponent INT16U
 778  * @param numberRssiMeasurements INT8U
 779  * @param reportingPeriod INT16U
 780  */
 781 #define emberAfFillCommandRSSI                                                                                                     \
 782     LocationClusterSetAbsoluteLocation(coordinate1, status, coordinate2, power, coordinate3, pathLossExponent, power,              \
 783                                        calculationPeriod, pathLossExponent, numberRssiMeasurements, reportingPeriod)               \
 784         emberAfFillExternalBuffer(mask,                                                                                            \
 785                                                                                                                                    \
 786                                   ZCL_SET_ABSOLUTE_LOCATION_COMMAND_ID, "uuuuuuuuuuu", coordinate1, status, coordinate2, power,    \
 787                                   coordinate3, pathLossExponent, power, calculationPeriod, pathLossExponent,                       \
 788                                   numberRssiMeasurements, reportingPeriod);
 789
 790 /** @brief Command description for SetDeviceConfiguration
 791  *
 792  * Command: SetDeviceConfiguration
 793  * @param power INT16S
 794  * @param status Status
 795  * @param pathLossExponent INT16U
 796  * @param locationType LocationType
 797  * @param calculationPeriod INT16U
 798  * @param coordinate1 INT16S
 799  * @param numberRssiMeasurements INT8U
 800  * @param coordinate2 INT16S
 801  * @param reportingPeriod INT16U
 802  * @param coordinate3 INT16S
 803  * @param power INT16S
 804  * @param pathLossExponent INT16U
 805  * @param locationMethod LocationMethod
 806  * @param qualityMeasure INT8U
 807  * @param locationAge INT16U
 808  */
 809 #define emberAfFillCommandRSSI                                                                                                     \
 810     LocationClusterSetDeviceConfiguration(power, status, pathLossExponent, locationType, calculationPeriod, coordinate1,           \
 811                                           numberRssiMeasurements, coordinate2, reportingPeriod, coordinate3, power,                \
 812                                           pathLossExponent, locationMethod, qualityMeasure, locationAge)                           \
 813         emberAfFillExternalBuffer(mask,                                                                                            \
 814                                                                                                                                    \
 815                                   ZCL_SET_DEVICE_CONFIGURATION_COMMAND_ID, "uuuuuuuuuuuuuuu", power, status, pathLossExponent,     \
 816                                   locationType, calculationPeriod, coordinate1, numberRssiMeasurements, coordinate2,               \
 817                                   reportingPeriod, coordinate3, power, pathLossExponent, locationMethod, qualityMeasure,           \
 818                                   locationAge);
 819
 820 /** @brief Command description for GetDeviceConfiguration
 821  *
 822  * Command: GetDeviceConfiguration
 823  * @param targetAddress IEEE_ADDRESS
 824  * @param locationType LocationType
 825  * @param coordinate1 INT16S
 826  * @param coordinate2 INT16S
 827  * @param coordinate3 INT16S
 828  * @param power INT16S
 829  * @param pathLossExponent INT16U
 830  * @param locationMethod LocationMethod
 831  * @param qualityMeasure INT8U
 832  * @param locationAge INT16U
 833  */
 834 #define emberAfFillCommandRSSI                                                                                                     \
 835     LocationClusterGetDeviceConfiguration(targetAddress, locationType, coordinate1, coordinate2, coordinate3, power,               \
 836                                           pathLossExponent, locationMethod, qualityMeasure, locationAge)                           \
 837         emberAfFillExternalBuffer(mask,                                                                                            \
 838                                                                                                                                    \
 839                                   ZCL_GET_DEVICE_CONFIGURATION_COMMAND_ID, "uuuuuuuuuu", targetAddress, locationType, coordinate1, \
 840                                   coordinate2, coordinate3, power, pathLossExponent, locationMethod, qualityMeasure, locationAge);
 841
 842 /** @brief Command description for GetLocationData
 843  *
 844  * Command: GetLocationData
 845  * @param flags GetLocationDataFlags
 846  * @param locationType LocationType
 847  * @param numberResponses INT8U
 848  * @param coordinate1 INT16S
 849  * @param targetAddress IEEE_ADDRESS
 850  * @param coordinate2 INT16S
 851  * @param coordinate3 INT16S
 852  * @param qualityMeasure INT8U
 853  * @param locationAge INT16U
 854  */
 855 #define emberAfFillCommandRSSI                                                                                                     \
 856     LocationClusterGetLocationData(flags, locationType, numberResponses, coordinate1, targetAddress, coordinate2, coordinate3,     \
 857                                    qualityMeasure, locationAge)                                                                    \
 858         emberAfFillExternalBuffer(mask,                                                                                            \
 859                                                                                                                                    \
 860                                   ZCL_GET_LOCATION_DATA_COMMAND_ID, "uuuuuuuuu", flags, locationType, numberResponses,             \
 861                                   coordinate1, targetAddress, coordinate2, coordinate3, qualityMeasure, locationAge);
 862
 863 /** @brief Command description for RssiResponse
 864  *
 865  * Command: RssiResponse
 866  * @param replyingDevice IEEE_ADDRESS
 867  * @param locationType LocationType
 868  * @param coordinate1 INT16S
 869  * @param coordinate2 INT16S
 870  * @param coordinate3 INT16S
 871  * @param rssi INT8S
 872  * @param numberRssiMeasurements INT8U
 873  */
 874 #define emberAfFillCommandRSSI                                                                                                     \
 875     LocationClusterRssiResponse(replyingDevice, locationType, coordinate1, coordinate2, coordinate3, rssi, numberRssiMeasurements) \
 876         emberAfFillExternalBuffer(mask,                                                                                            \
 877                                                                                                                                    \
 878                                   ZCL_RSSI_RESPONSE_COMMAND_ID, "uuuuuuu", replyingDevice, locationType, coordinate1, coordinate2, \
 879                                   coordinate3, rssi, numberRssiMeasurements);
 880
 881 /** @brief Command description for RssiRequest
 882  *
 883  * Command: RssiRequest
 884  * @param targetAddress IEEE_ADDRESS
 885  * @param numberRssiMeasurements INT8U
 886  * @param calculationPeriod INT16U
 887  */
 888 #define emberAfFillCommandRSSI                                                                                                     \
 889     LocationClusterRssiRequest(targetAddress, numberRssiMeasurements, calculationPeriod)                                           \
 890         emberAfFillExternalBuffer(mask,                                                                                            \
 891                                                                                                                                    \
 892                                   ZCL_RSSI_REQUEST_COMMAND_ID, "uuu", targetAddress, numberRssiMeasurements, calculationPeriod);
 893
 894 /** @brief Command description for AnchorNodeAnnounce
 895  *
 896  * Command: AnchorNodeAnnounce
 897  * @param anchorNodeIeeeAddress IEEE_ADDRESS
 898  * @param measuringDevice IEEE_ADDRESS
 899  * @param coordinate1 INT16S
 900  * @param neighbors INT8U
 901  * @param coordinate2 INT16S
 902  * @param neighborsInfo NeighborInfo []
 903  * @param neighborsInfoLen int
 904  * @param coordinate3 INT16S
 905  */
 906 #define emberAfFillCommandRSSI                                                                                                     \
 907     LocationClusterAnchorNodeAnnounce(anchorNodeIeeeAddress, measuringDevice, coordinate1, neighbors, coordinate2, neighborsInfo,  \
 908                                       neighborsInfoLen, coordinate3)                                                               \
 909         emberAfFillExternalBuffer(mask,                                                                                            \
 910                                                                                                                                    \
 911                                   ZCL_ANCHOR_NODE_ANNOUNCE_COMMAND_ID, "uuuuubu", anchorNodeIeeeAddress, measuringDevice,          \
 912                                   coordinate1, neighbors, coordinate2, neighborsInfo, neighborsInfoLen, coordinate3);
 913
 914 /** @brief Command description for RequestOwnLocation
 915  *
 916  * Command: RequestOwnLocation
 917  * @param blindNode IEEE_ADDRESS
 918  */
 919 #define emberAfFillCommandRSSI                                                                                                     \
 920     LocationClusterRequestOwnLocation(blindNode) emberAfFillExternalBuffer(mask,                                                   \
 921                                                                                                                                    \
 922                                                                            ZCL_REQUEST_OWN_LOCATION_COMMAND_ID, "u", blindNode);
 923
 924 /** @brief Command description for RestartDevice
 925  *
 926  * Command: RestartDevice
 927  * @param options RestartOptions
 928  * @param status ENUM8
 929  * @param delay INT8U
 930  * @param jitter INT8U
 931  */
 932 #define emberAfFillCommandCommissioningClusterRestartDevice(options, status, delay, jitter)                                        \
 933     emberAfFillExternalBuffer(mask,                                                                                                \
 934                                                                                                                                    \
 935                               ZCL_RESTART_DEVICE_COMMAND_ID, "uuuu", options, status, delay, jitter);
 936
 937 /** @brief Command description for SaveStartupParameters
 938  *
 939  * Command: SaveStartupParameters
 940  * @param options BITMAP8
 941  * @param status ENUM8
 942  * @param index INT8U
 943  */
 944 #define emberAfFillCommandCommissioningClusterSaveStartupParameters(options, status, index)                                        \
 945     emberAfFillExternalBuffer(mask,                                                                                                \
 946                                                                                                                                    \
 947                               ZCL_SAVE_STARTUP_PARAMETERS_COMMAND_ID, "uuu", options, status, index);
 948
 949 /** @brief Command description for RestoreStartupParameters
 950  *
 951  * Command: RestoreStartupParameters
 952  * @param options BITMAP8
 953  * @param status ENUM8
 954  * @param index INT8U
 955  */
 956 #define emberAfFillCommandCommissioningClusterRestoreStartupParameters(options, status, index)                                     \
 957     emberAfFillExternalBuffer(mask,                                                                                                \
 958                                                                                                                                    \
 959                               ZCL_RESTORE_STARTUP_PARAMETERS_COMMAND_ID, "uuu", options, status, index);
 960
 961 /** @brief Command description for ResetStartupParameters
 962  *
 963  * Command: ResetStartupParameters
 964  * @param options ResetOptions
 965  * @param status ENUM8
 966  * @param index INT8U
 967  */
 968 #define emberAfFillCommandCommissioningClusterResetStartupParameters(options, status, index)                                       \
 969     emberAfFillExternalBuffer(mask,                                                                                                \
 970                                                                                                                                    \
 971                               ZCL_RESET_STARTUP_PARAMETERS_COMMAND_ID, "uuu", options, status, index);
 972
 973 /** @brief Command description for TransferPartitionedFrame
 974  *
 975  * Command: TransferPartitionedFrame
 976  * @param fragmentationOptions BITMAP8
 977  * @param ackOptions BITMAP8
 978  * @param partitionedIndicatorAndFrame INT8U []
 979  * @param partitionedIndicatorAndFrameLen int
 980  * @param firstFrameIdAndNackList INT8U []
 981  * @param firstFrameIdAndNackListLen int
 982  */
 983 #define emberAfFillCommandPartitionClusterTransferPartitionedFrame(fragmentationOptions, ackOptions, partitionedIndicatorAndFrame, \
 984                                                                    partitionedIndicatorAndFrameLen, firstFrameIdAndNackList,       \
 985                                                                    firstFrameIdAndNackListLen)                                     \
 986     emberAfFillExternalBuffer(mask,                                                                                                \
 987                                                                                                                                    \
 988                               ZCL_TRANSFER_PARTITIONED_FRAME_COMMAND_ID, "uubb", fragmentationOptions, ackOptions,                 \
 989                               partitionedIndicatorAndFrame, partitionedIndicatorAndFrameLen, firstFrameIdAndNackList,              \
 990                               firstFrameIdAndNackListLen);
 991
 992 /** @brief Command description for ReadHandshakeParam
 993  *
 994  * Command: ReadHandshakeParam
 995  * @param partitionedClusterId CLUSTER_ID
 996  * @param partitionedClusterId CLUSTER_ID
 997  * @param attributeList ATTRIBUTE_ID []
 998  * @param attributeListLen int
 999  * @param readAttributeStatusRecords ReadAttributeStatusRecord []
1000  * @param readAttributeStatusRecordsLen int
1001  */
1002 #define emberAfFillCommandPartitionClusterReadHandshakeParam(partitionedClusterId, partitionedClusterId, attributeList,            \
1003                                                              attributeListLen, readAttributeStatusRecords,                         \
1004                                                              readAttributeStatusRecordsLen)                                        \
1005     emberAfFillExternalBuffer(mask,                                                                                                \
1006                                                                                                                                    \
1007                               ZCL_READ_HANDSHAKE_PARAM_COMMAND_ID, "uubb", partitionedClusterId, partitionedClusterId,             \
1008                               attributeList, attributeListLen, readAttributeStatusRecords, readAttributeStatusRecordsLen);
1009
1010 /** @brief Command description for WriteHandshakeParam
1011  *
1012  * Command: WriteHandshakeParam
1013  * @param partitionedClusterId CLUSTER_ID
1014  * @param writeAttributeRecords WriteAttributeRecord []
1015  * @param writeAttributeRecordsLen int
1016  */
1017 #define emberAfFillCommandPartitionClusterWriteHandshakeParam(partitionedClusterId, writeAttributeRecords,                         \
1018                                                               writeAttributeRecordsLen)                                            \
1019     emberAfFillExternalBuffer(mask,                                                                                                \
1020                                                                                                                                    \
1021                               ZCL_WRITE_HANDSHAKE_PARAM_COMMAND_ID, "ub", partitionedClusterId, writeAttributeRecords,             \
1022                               writeAttributeRecordsLen);
1023
1024 /** @brief Command description for ImageNotify
1025  *
1026  * Command: ImageNotify
1027  * @param payloadType ENUM8
1028  * @param queryJitter INT8U
1029  * @param manufacturerId INT16U
1030  * @param imageType INT16U
1031  * @param newFileVersion INT32U
1032  */
1033 #define emberAfFillCommandOver                                                                                                     \
1034     the Air BootloadingClusterImageNotify(payloadType, queryJitter, manufacturerId, imageType, newFileVersion)                     \
1035         emberAfFillExternalBuffer(mask,                                                                                            \
1036                                                                                                                                    \
1037                                   ZCL_IMAGE_NOTIFY_COMMAND_ID, "uuuuu", payloadType, queryJitter, manufacturerId, imageType,       \
1038                                   newFileVersion);
1039
1040 /** @brief Command description for QueryNextImageRequest
1041  *
1042  * Command: QueryNextImageRequest
1043  * @param fieldControl INT8U
1044  * @param manufacturerId INT16U
1045  * @param imageType INT16U
1046  * @param currentFileVersion INT32U
1047  * @param hardwareVersion INT16U
1048  */
1049 #define emberAfFillCommandOver                                                                                                     \
1050     the Air BootloadingClusterQueryNextImageRequest(fieldControl, manufacturerId, imageType, currentFileVersion, hardwareVersion)  \
1051         emberAfFillExternalBuffer(mask,                                                                                            \
1052                                                                                                                                    \
1053                                   ZCL_QUERY_NEXT_IMAGE_REQUEST_COMMAND_ID, "uuuuu", fieldControl, manufacturerId, imageType,       \
1054                                   currentFileVersion, hardwareVersion);
1055
1056 /** @brief Command description for QueryNextImageResponse
1057  *
1058  * Command: QueryNextImageResponse
1059  * @param status Status
1060  * @param manufacturerId INT16U
1061  * @param imageType INT16U
1062  * @param fileVersion INT32U
1063  * @param imageSize INT32U
1064  */
1065 #define emberAfFillCommandOver                                                                                                     \
1066     the Air BootloadingClusterQueryNextImageResponse(status, manufacturerId, imageType, fileVersion, imageSize)                    \
1067         emberAfFillExternalBuffer(mask,                                                                                            \
1068                                                                                                                                    \
1069                                   ZCL_QUERY_NEXT_IMAGE_RESPONSE_COMMAND_ID, "uuuuu", status, manufacturerId, imageType,            \
1070                                   fileVersion, imageSize);
1071
1072 /** @brief Command description for ImageBlockRequest
1073  *
1074  * Command: ImageBlockRequest
1075  * @param fieldControl INT8U
1076  * @param manufacturerId INT16U
1077  * @param imageType INT16U
1078  * @param fileVersion INT32U
1079  * @param fileOffset INT32U
1080  * @param maxDataSize INT8U
1081  * @param requestNodeAddress IEEE_ADDRESS
1082  */
1083 #define emberAfFillCommandOver                                                                                                     \
1084     the Air BootloadingClusterImageBlockRequest(fieldControl, manufacturerId, imageType, fileVersion, fileOffset, maxDataSize,     \
1085                                                 requestNodeAddress)                                                                \
1086         emberAfFillExternalBuffer(mask,                                                                                            \
1087                                                                                                                                    \
1088                                   ZCL_IMAGE_BLOCK_REQUEST_COMMAND_ID, "uuuuuuu", fieldControl, manufacturerId, imageType,          \
1089                                   fileVersion, fileOffset, maxDataSize, requestNodeAddress);
1090
1091 /** @brief Command description for ImagePageRequest
1092  *
1093  * Command: ImagePageRequest
1094  * @param fieldControl INT8U
1095  * @param manufacturerId INT16U
1096  * @param imageType INT16U
1097  * @param fileVersion INT32U
1098  * @param fileOffset INT32U
1099  * @param maxDataSize INT8U
1100  * @param pageSize INT16U
1101  * @param responseSpacing INT16U
1102  * @param requestNodeAddress IEEE_ADDRESS
1103  */
1104 #define emberAfFillCommandOver                                                                                                     \
1105     the Air BootloadingClusterImagePageRequest(fieldControl, manufacturerId, imageType, fileVersion, fileOffset, maxDataSize,      \
1106                                                pageSize, responseSpacing, requestNodeAddress)                                      \
1107         emberAfFillExternalBuffer(mask,                                                                                            \
1108                                                                                                                                    \
1109                                   ZCL_IMAGE_PAGE_REQUEST_COMMAND_ID, "uuuuuuuuu", fieldControl, manufacturerId, imageType,         \
1110                                   fileVersion, fileOffset, maxDataSize, pageSize, responseSpacing, requestNodeAddress);
1111
1112 /** @brief Command description for ImageBlockResponse
1113  *
1114  * Command: ImageBlockResponse
1115  * @param status Status
1116  * @param manufacturerId INT16U
1117  * @param imageType INT16U
1118  * @param fileVersion INT32U
1119  * @param fileOffset INT32U
1120  * @param dataSize INT8U
1121  * @param imageData INT8U []
1122  * @param imageDataLen int
1123  */
1124 #define emberAfFillCommandOver                                                                                                     \
1125     the Air BootloadingClusterImageBlockResponse(status, manufacturerId, imageType, fileVersion, fileOffset, dataSize, imageData,  \
1126                                                  imageDataLen)                                                                     \
1127         emberAfFillExternalBuffer(mask,                                                                                            \
1128                                                                                                                                    \
1129                                   ZCL_IMAGE_BLOCK_RESPONSE_COMMAND_ID, "uuuuuub", status, manufacturerId, imageType, fileVersion,  \
1130                                   fileOffset, dataSize, imageData, imageDataLen);
1131
1132 /** @brief Command description for UpgradeEndRequest
1133  *
1134  * Command: UpgradeEndRequest
1135  * @param status Status
1136  * @param manufacturerId INT16U
1137  * @param imageType INT16U
1138  * @param fileVersion INT32U
1139  */
1140 #define emberAfFillCommandOver                                                                                                     \
1141     the Air BootloadingClusterUpgradeEndRequest(status, manufacturerId, imageType, fileVersion)                                    \
1142         emberAfFillExternalBuffer(mask,                                                                                            \
1143                                                                                                                                    \
1144                                   ZCL_UPGRADE_END_REQUEST_COMMAND_ID, "uuuu", status, manufacturerId, imageType, fileVersion);
1145
1146 /** @brief Command description for UpgradeEndResponse
1147  *
1148  * Command: UpgradeEndResponse
1149  * @param manufacturerId INT16U
1150  * @param imageType INT16U
1151  * @param fileVersion INT32U
1152  * @param currentTime UTC_TIME
1153  * @param upgradeTime UTC_TIME
1154  */
1155 #define emberAfFillCommandOver                                                                                                     \
1156     the Air BootloadingClusterUpgradeEndResponse(manufacturerId, imageType, fileVersion, currentTime, upgradeTime)                 \
1157         emberAfFillExternalBuffer(mask,                                                                                            \
1158                                                                                                                                    \
1159                                   ZCL_UPGRADE_END_RESPONSE_COMMAND_ID, "uuuuu", manufacturerId, imageType, fileVersion,            \
1160                                   currentTime, upgradeTime);
1161
1162 /** @brief Command description for QuerySpecificFileRequest
1163  *
1164  * Command: QuerySpecificFileRequest
1165  * @param requestNodeAddress IEEE_ADDRESS
1166  * @param manufacturerId INT16U
1167  * @param imageType INT16U
1168  * @param fileVersion INT32U
1169  * @param currentZigbeeStackVersion INT16U
1170  */
1171 #define emberAfFillCommandOver                                                                                                     \
1172     the Air BootloadingClusterQuerySpecificFileRequest(requestNodeAddress, manufacturerId, imageType, fileVersion,                 \
1173                                                        currentZigbeeStackVersion)                                                  \
1174         emberAfFillExternalBuffer(mask,                                                                                            \
1175                                                                                                                                    \
1176                                   ZCL_QUERY_SPECIFIC_FILE_REQUEST_COMMAND_ID, "uuuuu", requestNodeAddress, manufacturerId,         \
1177                                   imageType, fileVersion, currentZigbeeStackVersion);
1178
1179 /** @brief Command description for QuerySpecificFileResponse
1180  *
1181  * Command: QuerySpecificFileResponse
1182  * @param status Status
1183  * @param manufacturerId INT16U
1184  * @param imageType INT16U
1185  * @param fileVersion INT32U
1186  * @param imageSize INT32U
1187  */
1188 #define emberAfFillCommandOver                                                                                                     \
1189     the Air BootloadingClusterQuerySpecificFileResponse(status, manufacturerId, imageType, fileVersion, imageSize)                 \
1190         emberAfFillExternalBuffer(mask,                                                                                            \
1191                                                                                                                                    \
1192                                   ZCL_QUERY_SPECIFIC_FILE_RESPONSE_COMMAND_ID, "uuuuu", status, manufacturerId, imageType,         \
1193                                   fileVersion, imageSize);
1194
1195 /** @brief Command description for PowerProfileRequest
1196  *
1197  * Command: PowerProfileRequest
1198  * @param powerProfileId INT8U
1199  * @param totalProfileNum INT8U
1200  * @param powerProfileId INT8U
1201  * @param numOfTransferredPhases INT8U
1202  * @param transferredPhases TransferredPhase []
1203  * @param transferredPhasesLen int
1204  */
1205 #define emberAfFillCommandPower                                                                                                    \
1206     ProfileClusterPowerProfileRequest(powerProfileId, totalProfileNum, powerProfileId, numOfTransferredPhases, transferredPhases,  \
1207                                       transferredPhasesLen)                                                                        \
1208         emberAfFillExternalBuffer(mask,                                                                                            \
1209                                                                                                                                    \
1210                                   ZCL_POWER_PROFILE_REQUEST_COMMAND_ID, "uuuub", powerProfileId, totalProfileNum, powerProfileId,  \
1211                                   numOfTransferredPhases, transferredPhases, transferredPhasesLen);
1212
1213 /** @brief Command description for PowerProfileStateRequest
1214  *
1215  * Command: PowerProfileStateRequest
1216  * @param totalProfileNum INT8U
1217  * @param powerProfileId INT8U
1218  * @param numOfTransferredPhases INT8U
1219  * @param transferredPhases TransferredPhase []
1220  * @param transferredPhasesLen int
1221  */
1222 #define emberAfFillCommandPower                                                                                                    \
1223     ProfileClusterPowerProfileStateRequest(totalProfileNum, powerProfileId, numOfTransferredPhases, transferredPhases,             \
1224                                            transferredPhasesLen)                                                                   \
1225         emberAfFillExternalBuffer(mask,                                                                                            \
1226                                                                                                                                    \
1227                                   ZCL_POWER_PROFILE_STATE_REQUEST_COMMAND_ID, "uuub", totalProfileNum, powerProfileId,             \
1228                                   numOfTransferredPhases, transferredPhases, transferredPhasesLen);
1229
1230 /** @brief Command description for GetPowerProfilePriceResponse
1231  *
1232  * Command: GetPowerProfilePriceResponse
1233  * @param powerProfileId INT8U
1234  * @param powerProfileCount INT8U
1235  * @param currency INT16U
1236  * @param powerProfileRecords PowerProfileRecord []
1237  * @param powerProfileRecordsLen int
1238  * @param price INT32U
1239  * @param priceTrailingDigit INT8U
1240  */
1241 #define emberAfFillCommandPower                                                                                                    \
1242     ProfileClusterGetPowerProfilePriceResponse(powerProfileId, powerProfileCount, currency, powerProfileRecords,                   \
1243                                                powerProfileRecordsLen, price, priceTrailingDigit)                                  \
1244         emberAfFillExternalBuffer(mask,                                                                                            \
1245                                                                                                                                    \
1246                                   ZCL_GET_POWER_PROFILE_PRICE_RESPONSE_COMMAND_ID, "uuubuu", powerProfileId, powerProfileCount,    \
1247                                   currency, powerProfileRecords, powerProfileRecordsLen, price, priceTrailingDigit);
1248
1249 /** @brief Command description for GetOverallSchedulePriceResponse
1250  *
1251  * Command: GetOverallSchedulePriceResponse
1252  * @param currency INT16U
1253  * @param powerProfileId INT8U
1254  * @param price INT32U
1255  * @param priceTrailingDigit INT8U
1256  */
1257 #define emberAfFillCommandPower                                                                                                    \
1258     ProfileClusterGetOverallSchedulePriceResponse(currency, powerProfileId, price, priceTrailingDigit) emberAfFillExternalBuffer(  \
1259         mask,                                                                                                                      \
1260                                                                                                                                    \
1261         ZCL_GET_OVERALL_SCHEDULE_PRICE_RESPONSE_COMMAND_ID, "uuuu", currency, powerProfileId, price, priceTrailingDigit);
1262
1263 /** @brief Command description for EnergyPhasesScheduleNotification
1264  *
1265  * Command: EnergyPhasesScheduleNotification
1266  * @param powerProfileId INT8U
1267  * @param powerProfileCount INT8U
1268  * @param numOfScheduledPhases INT8U
1269  * @param powerProfileRecords PowerProfileRecord []
1270  * @param powerProfileRecordsLen int
1271  * @param scheduledPhases ScheduledPhase []
1272  * @param scheduledPhasesLen int
1273  */
1274 #define emberAfFillCommandPower                                                                                                    \
1275     ProfileClusterEnergyPhasesScheduleNotification(powerProfileId, powerProfileCount, numOfScheduledPhases, powerProfileRecords,   \
1276                                                    powerProfileRecordsLen, scheduledPhases, scheduledPhasesLen)                    \
1277         emberAfFillExternalBuffer(mask,                                                                                            \
1278                                                                                                                                    \
1279                                   ZCL_ENERGY_PHASES_SCHEDULE_NOTIFICATION_COMMAND_ID, "uuubb", powerProfileId, powerProfileCount,  \
1280                                   numOfScheduledPhases, powerProfileRecords, powerProfileRecordsLen, scheduledPhases,              \
1281                                   scheduledPhasesLen);
1282
1283 /** @brief Command description for GetOverallSchedulePrice
1284  *
1285  * Command: GetOverallSchedulePrice
1286  * @param powerProfileId INT8U
1287  * @param numOfScheduledPhases INT8U
1288  * @param scheduledPhases ScheduledPhase []
1289  * @param scheduledPhasesLen int
1290  */
1291 #define emberAfFillCommandPower                                                                                                    \
1292     ProfileClusterGetOverallSchedulePrice(powerProfileId, numOfScheduledPhases, scheduledPhases, scheduledPhasesLen)               \
1293         emberAfFillExternalBuffer(mask,                                                                                            \
1294                                                                                                                                    \
1295                                   ZCL_GET_OVERALL_SCHEDULE_PRICE_COMMAND_ID, "uub", powerProfileId, numOfScheduledPhases,          \
1296                                   scheduledPhases, scheduledPhasesLen);
1297
1298 /** @brief Command description for PowerProfileScheduleConstraintsRequest
1299  *
1300  * Command: PowerProfileScheduleConstraintsRequest
1301  * @param powerProfileId INT8U
1302  * @param powerProfileId INT8U
1303  */
1304 #define emberAfFillCommandPower                                                                                                    \
1305     ProfileClusterPowerProfileScheduleConstraintsRequest(powerProfileId, powerProfileId) emberAfFillExternalBuffer(                \
1306         mask,                                                                                                                      \
1307                                                                                                                                    \
1308         ZCL_POWER_PROFILE_SCHEDULE_CONSTRAINTS_REQUEST_COMMAND_ID, "uu", powerProfileId, powerProfileId);
1309
1310 /** @brief Command description for EnergyPhasesScheduleStateRequest
1311  *
1312  * Command: EnergyPhasesScheduleStateRequest
1313  * @param powerProfileId INT8U
1314  * @param powerProfileId INT8U
1315  * @param numOfScheduledPhases INT8U
1316  * @param scheduledPhases ScheduledPhase []
1317  * @param scheduledPhasesLen int
1318  */
1319 #define emberAfFillCommandPower                                                                                                    \
1320     ProfileClusterEnergyPhasesScheduleStateRequest(powerProfileId, powerProfileId, numOfScheduledPhases, scheduledPhases,          \
1321                                                    scheduledPhasesLen)                                                             \
1322         emberAfFillExternalBuffer(mask,                                                                                            \
1323                                                                                                                                    \
1324                                   ZCL_ENERGY_PHASES_SCHEDULE_STATE_REQUEST_COMMAND_ID, "uuub", powerProfileId, powerProfileId,     \
1325                                   numOfScheduledPhases, scheduledPhases, scheduledPhasesLen);
1326
1327 /** @brief Command description for GetPowerProfilePriceExtendedResponse
1328  *
1329  * Command: GetPowerProfilePriceExtendedResponse
1330  * @param powerProfileId INT8U
1331  * @param powerProfileId INT8U
1332  * @param currency INT16U
1333  * @param numOfScheduledPhases INT8U
1334  * @param price INT32U
1335  * @param scheduledPhases ScheduledPhase []
1336  * @param scheduledPhasesLen int
1337  * @param priceTrailingDigit INT8U
1338  */
1339 #define emberAfFillCommandPower                                                                                                    \
1340     ProfileClusterGetPowerProfilePriceExtendedResponse(powerProfileId, powerProfileId, currency, numOfScheduledPhases, price,      \
1341                                                        scheduledPhases, scheduledPhasesLen, priceTrailingDigit)                    \
1342         emberAfFillExternalBuffer(mask,                                                                                            \
1343                                                                                                                                    \
1344                                   ZCL_GET_POWER_PROFILE_PRICE_EXTENDED_RESPONSE_COMMAND_ID, "uuuuubu", powerProfileId,             \
1345                                   powerProfileId, currency, numOfScheduledPhases, price, scheduledPhases, scheduledPhasesLen,      \
1346                                   priceTrailingDigit);
1347
1348 /** @brief Command description for PowerProfileScheduleConstraintsNotification
1349  *
1350  * Command: PowerProfileScheduleConstraintsNotification
1351  * @param powerProfileId INT8U
1352  * @param startAfter INT16U
1353  * @param stopBefore INT16U
1354  */
1355 #define emberAfFillCommandPower                                                                                                    \
1356     ProfileClusterPowerProfileScheduleConstraintsNotification(powerProfileId, startAfter, stopBefore) emberAfFillExternalBuffer(   \
1357         mask,                                                                                                                      \
1358                                                                                                                                    \
1359         ZCL_POWER_PROFILE_SCHEDULE_CONSTRAINTS_NOTIFICATION_COMMAND_ID, "uuu", powerProfileId, startAfter, stopBefore);
1360
1361 /** @brief Command description for PowerProfileScheduleConstraintsResponse
1362  *
1363  * Command: PowerProfileScheduleConstraintsResponse
1364  * @param powerProfileId INT8U
1365  * @param startAfter INT16U
1366  * @param stopBefore INT16U
1367  */
1368 #define emberAfFillCommandPower                                                                                                    \
1369     ProfileClusterPowerProfileScheduleConstraintsResponse(powerProfileId, startAfter, stopBefore) emberAfFillExternalBuffer(       \
1370         mask,                                                                                                                      \
1371                                                                                                                                    \
1372         ZCL_POWER_PROFILE_SCHEDULE_CONSTRAINTS_RESPONSE_COMMAND_ID, "uuu", powerProfileId, startAfter, stopBefore);
1373
1374 /** @brief Command description for GetPowerProfilePriceExtended
1375  *
1376  * Command: GetPowerProfilePriceExtended
1377  * @param options BITMAP8
1378  * @param powerProfileId INT8U
1379  * @param powerProfileStartTime INT16U
1380  */
1381 #define emberAfFillCommandPower                                                                                                    \
1382     ProfileClusterGetPowerProfilePriceExtended(options, powerProfileId, powerProfileStartTime) emberAfFillExternalBuffer(          \
1383         mask,                                                                                                                      \
1384                                                                                                                                    \
1385         ZCL_GET_POWER_PROFILE_PRICE_EXTENDED_COMMAND_ID, "uuu", options, powerProfileId, powerProfileStartTime);
1386
1387 /** @brief Command description for ExecutionOfACommand
1388  *
1389  * Command: ExecutionOfACommand
1390  * @param commandId CommandIdentification
1391  * @param applianceStatus ApplianceStatus
1392  * @param remoteEnableFlagsAndDeviceStatus2 RemoteEnableFlagsAndDeviceStatus2
1393  * @param applianceStatus2 INT24U
1394  */
1395 #define emberAfFillCommandAppliance                                                                                                \
1396     ControlClusterExecutionOfACommand(commandId, applianceStatus, remoteEnableFlagsAndDeviceStatus2, applianceStatus2)             \
1397         emberAfFillExternalBuffer(mask,                                                                                            \
1398                                                                                                                                    \
1399                                   ZCL_EXECUTION_OF_A_COMMAND_COMMAND_ID, "uuuu", commandId, applianceStatus,                       \
1400                                   remoteEnableFlagsAndDeviceStatus2, applianceStatus2);
1401
1402 /** @brief Command description for SignalState
1403  *
1404  * Command: SignalState
1405  * @param applianceStatus ApplianceStatus
1406  * @param remoteEnableFlagsAndDeviceStatus2 RemoteEnableFlagsAndDeviceStatus2
1407  * @param applianceStatus2 INT24U
1408  */
1409 #define emberAfFillCommandAppliance                                                                                                \
1410     ControlClusterSignalState(applianceStatus, remoteEnableFlagsAndDeviceStatus2, applianceStatus2) emberAfFillExternalBuffer(     \
1411         mask,                                                                                                                      \
1412                                                                                                                                    \
1413         ZCL_SIGNAL_STATE_COMMAND_ID, "uuu", applianceStatus, remoteEnableFlagsAndDeviceStatus2, applianceStatus2);
1414
1415 /** @brief Command description for WriteFunctions
1416  *
1417  * Command: WriteFunctions
1418  * @param functionId INT16U
1419  * @param functionDataType ENUM8
1420  * @param functionData INT8U []
1421  * @param functionDataLen int
1422  */
1423 #define emberAfFillCommandAppliance                                                                                                \
1424     ControlClusterWriteFunctions(functionId, functionDataType, functionData, functionDataLen) emberAfFillExternalBuffer(           \
1425         mask,                                                                                                                      \
1426                                                                                                                                    \
1427         ZCL_WRITE_FUNCTIONS_COMMAND_ID, "uub", functionId, functionDataType, functionData, functionDataLen);
1428
1429 /** @brief Command description for OverloadPauseResume
1430  *
1431  * Command: OverloadPauseResume
1432  */
1433 #define emberAfFillCommandAppliance                                                                                                \
1434     ControlClusterOverloadPauseResume() emberAfFillExternalBuffer(mask,                                                            \
1435                                                                                                                                    \
1436                                                                   ZCL_OVERLOAD_PAUSE_RESUME_COMMAND_ID, "", );
1437
1438 /** @brief Command description for OverloadPause
1439  *
1440  * Command: OverloadPause
1441  */
1442 #define emberAfFillCommandAppliance                                                                                                \
1443     ControlClusterOverloadPause() emberAfFillExternalBuffer(mask,                                                                  \
1444                                                                                                                                    \
1445                                                             ZCL_OVERLOAD_PAUSE_COMMAND_ID, "", );
1446
1447 /** @brief Command description for OverloadWarning
1448  *
1449  * Command: OverloadWarning
1450  * @param warningEvent WarningEvent
1451  */
1452 #define emberAfFillCommandAppliance                                                                                                \
1453     ControlClusterOverloadWarning(warningEvent) emberAfFillExternalBuffer(mask,                                                    \
1454                                                                                                                                    \
1455                                                                           ZCL_OVERLOAD_WARNING_COMMAND_ID, "u", warningEvent);
1456
1457 /** @brief Command description for CheckIn
1458  *
1459  * Command: CheckIn
1460  * @param startFastPolling BOOLEAN
1461  * @param fastPollTimeout INT16U
1462  */
1463 #define emberAfFillCommandPoll                                                                                                     \
1464     ControlClusterCheckIn(startFastPolling, fastPollTimeout)                                                                       \
1465         emberAfFillExternalBuffer(mask,                                                                                            \
1466                                                                                                                                    \
1467                                   ZCL_CHECK_IN_COMMAND_ID, "uu", startFastPolling, fastPollTimeout);
1468
1469 /** @brief Command description for FastPollStop
1470  *
1471  * Command: FastPollStop
1472  */
1473 #define emberAfFillCommandPoll                                                                                                     \
1474     ControlClusterFastPollStop() emberAfFillExternalBuffer(mask,                                                                   \
1475                                                                                                                                    \
1476                                                            ZCL_FAST_POLL_STOP_COMMAND_ID, "", );
1477
1478 /** @brief Command description for SetLongPollInterval
1479  *
1480  * Command: SetLongPollInterval
1481  * @param newLongPollInterval INT32U
1482  */
1483 #define emberAfFillCommandPoll                                                                                                     \
1484     ControlClusterSetLongPollInterval(newLongPollInterval)                                                                         \
1485         emberAfFillExternalBuffer(mask,                                                                                            \
1486                                                                                                                                    \
1487                                   ZCL_SET_LONG_POLL_INTERVAL_COMMAND_ID, "u", newLongPollInterval);
1488
1489 /** @brief Command description for SetShortPollInterval
1490  *
1491  * Command: SetShortPollInterval
1492  * @param newShortPollInterval INT16U
1493  */
1494 #define emberAfFillCommandPoll                                                                                                     \
1495     ControlClusterSetShortPollInterval(newShortPollInterval)                                                                       \
1496         emberAfFillExternalBuffer(mask,                                                                                            \
1497                                                                                                                                    \
1498                                   ZCL_SET_SHORT_POLL_INTERVAL_COMMAND_ID, "u", newShortPollInterval);
1499
1500 /** @brief Command description for GpNotification
1501  *
1502  * Command: GpNotification
1503  * @param options GpNotificationOption
1504  * @param options GpNotificationResponseOption
1505  * @param gpdSrcId INT32U
1506  * @param gpdSrcId INT32U
1507  * @param gpdIeee IEEE_ADDRESS
1508  * @param gpdIeee IEEE_ADDRESS
1509  * @param gpdEndpoint INT8U
1510  * @param endpoint INT8U
1511  * @param gpdSecurityFrameCounter INT32U
1512  * @param gpdSecurityFrameCounter INT32U
1513  * @param gpdCommandId INT8U
1514  * @param gpdCommandPayload OCTET_STRING
1515  * @param gppShortAddress INT16U
1516  * @param gppDistance INT8U
1517  */
1518 #define emberAfFillCommandGreen                                                                                                    \
1519     PowerClusterGpNotification(options, options, gpdSrcId, gpdSrcId, gpdIeee, gpdIeee, gpdEndpoint, endpoint,                      \
1520                                gpdSecurityFrameCounter, gpdSecurityFrameCounter, gpdCommandId, gpdCommandPayload, gppShortAddress, \
1521                                gppDistance)                                                                                        \
1522         emberAfFillExternalBuffer(mask,                                                                                            \
1523                                                                                                                                    \
1524                                   ZCL_GP_NOTIFICATION_COMMAND_ID, "uuuuuuuuuuuuuu", options, options, gpdSrcId, gpdSrcId, gpdIeee, \
1525                                   gpdIeee, gpdEndpoint, endpoint, gpdSecurityFrameCounter, gpdSecurityFrameCounter, gpdCommandId,  \
1526                                   gpdCommandPayload, gppShortAddress, gppDistance);
1527
1528 /** @brief Command description for GpPairingSearch
1529  *
1530  * Command: GpPairingSearch
1531  * @param options GpPairingSearchOption
1532  * @param options GpPairingOption
1533  * @param gpdSrcId INT32U
1534  * @param gpdSrcId INT32U
1535  * @param gpdIeee IEEE_ADDRESS
1536  * @param gpdIeee IEEE_ADDRESS
1537  * @param endpoint INT8U
1538  * @param endpoint INT8U
1539  * @param sinkIeeeAddress IEEE_ADDRESS
1540  * @param sinkNwkAddress INT16U
1541  * @param sinkGroupId INT16U
1542  * @param deviceId GpDeviceId
1543  * @param gpdSecurityFrameCounter INT32U
1544  * @param gpdKey SECURITY_KEY
1545  * @param assignedAlias INT16U
1546  * @param groupcastRadius INT8U
1547  */
1548 #define emberAfFillCommandGreen                                                                                                    \
1549     PowerClusterGpPairingSearch(options, options, gpdSrcId, gpdSrcId, gpdIeee, gpdIeee, endpoint, endpoint, sinkIeeeAddress,       \
1550                                 sinkNwkAddress, sinkGroupId, deviceId, gpdSecurityFrameCounter, gpdKey, assignedAlias,             \
1551                                 groupcastRadius)                                                                                   \
1552         emberAfFillExternalBuffer(mask,                                                                                            \
1553                                                                                                                                    \
1554                                   ZCL_GP_PAIRING_SEARCH_COMMAND_ID, "uuuuuuuuuuuuuuuu", options, options, gpdSrcId, gpdSrcId,      \
1555                                   gpdIeee, gpdIeee, endpoint, endpoint, sinkIeeeAddress, sinkNwkAddress, sinkGroupId, deviceId,    \
1556                                   gpdSecurityFrameCounter, gpdKey, assignedAlias, groupcastRadius);
1557
1558 /** @brief Command description for GpProxyCommissioningMode
1559  *
1560  * Command: GpProxyCommissioningMode
1561  * @param options GpProxyCommissioningModeOption
1562  * @param commissioningWindow INT16U
1563  * @param channel INT8U
1564  */
1565 #define emberAfFillCommandGreen                                                                                                    \
1566     PowerClusterGpProxyCommissioningMode(options, commissioningWindow, channel)                                                    \
1567         emberAfFillExternalBuffer(mask,                                                                                            \
1568                                                                                                                                    \
1569                                   ZCL_GP_PROXY_COMMISSIONING_MODE_COMMAND_ID, "uuu", options, commissioningWindow, channel);
1570
1571 /** @brief Command description for GpTunnelingStop
1572  *
1573  * Command: GpTunnelingStop
1574  * @param options GpTunnelingStopOption
1575  * @param gpdSrcId INT32U
1576  * @param gpdIeee IEEE_ADDRESS
1577  * @param endpoint INT8U
1578  * @param gpdSecurityFrameCounter INT32U
1579  * @param gppShortAddress INT16U
1580  * @param gppDistance INT8S
1581  */
1582 #define emberAfFillCommandGreen                                                                                                    \
1583     PowerClusterGpTunnelingStop(options, gpdSrcId, gpdIeee, endpoint, gpdSecurityFrameCounter, gppShortAddress, gppDistance)       \
1584         emberAfFillExternalBuffer(mask,                                                                                            \
1585                                                                                                                                    \
1586                                   ZCL_GP_TUNNELING_STOP_COMMAND_ID, "uuuuuuu", options, gpdSrcId, gpdIeee, endpoint,               \
1587                                   gpdSecurityFrameCounter, gppShortAddress, gppDistance);
1588
1589 /** @brief Command description for GpCommissioningNotification
1590  *
1591  * Command: GpCommissioningNotification
1592  * @param options GpCommissioningNotificationOption
1593  * @param gpdSrcId INT32U
1594  * @param gpdIeee IEEE_ADDRESS
1595  * @param endpoint INT8U
1596  * @param gpdSecurityFrameCounter INT32U
1597  * @param gpdCommandId INT8U
1598  * @param gpdCommandPayload OCTET_STRING
1599  * @param gppShortAddress INT16U
1600  * @param gppLink INT8U
1601  * @param mic INT32U
1602  */
1603 #define emberAfFillCommandGreen                                                                                                    \
1604     PowerClusterGpCommissioningNotification(options, gpdSrcId, gpdIeee, endpoint, gpdSecurityFrameCounter, gpdCommandId,           \
1605                                             gpdCommandPayload, gppShortAddress, gppLink, mic)                                      \
1606         emberAfFillExternalBuffer(mask,                                                                                            \
1607                                                                                                                                    \
1608                                   ZCL_GP_COMMISSIONING_NOTIFICATION_COMMAND_ID, "uuuuuuuuuu", options, gpdSrcId, gpdIeee,          \
1609                                   endpoint, gpdSecurityFrameCounter, gpdCommandId, gpdCommandPayload, gppShortAddress, gppLink,    \
1610                                   mic);
1611
1612 /** @brief Command description for GpSinkCommissioningMode
1613  *
1614  * Command: GpSinkCommissioningMode
1615  * @param options GpSinkCommissioningModeOptions
1616  * @param gpmAddrForSecurity INT16U
1617  * @param gpmAddrForPairing INT16U
1618  * @param sinkEndpoint INT8U
1619  */
1620 #define emberAfFillCommandGreen                                                                                                    \
1621     PowerClusterGpSinkCommissioningMode(options, gpmAddrForSecurity, gpmAddrForPairing, sinkEndpoint) emberAfFillExternalBuffer(   \
1622         mask,                                                                                                                      \
1623                                                                                                                                    \
1624         ZCL_GP_SINK_COMMISSIONING_MODE_COMMAND_ID, "uuuu", options, gpmAddrForSecurity, gpmAddrForPairing, sinkEndpoint);
1625
1626 /** @brief Command description for GpResponse
1627  *
1628  * Command: GpResponse
1629  * @param options GpResponseOption
1630  * @param tempMasterShortAddress INT16U
1631  * @param tempMasterTxChannel BITMAP8
1632  * @param gpdSrcId INT32U
1633  * @param gpdIeee IEEE_ADDRESS
1634  * @param endpoint INT8U
1635  * @param gpdCommandId INT8U
1636  * @param gpdCommandPayload OCTET_STRING
1637  */
1638 #define emberAfFillCommandGreen                                                                                                    \
1639     PowerClusterGpResponse(options, tempMasterShortAddress, tempMasterTxChannel, gpdSrcId, gpdIeee, endpoint, gpdCommandId,        \
1640                            gpdCommandPayload)                                                                                      \
1641         emberAfFillExternalBuffer(mask,                                                                                            \
1642                                                                                                                                    \
1643                                   ZCL_GP_RESPONSE_COMMAND_ID, "uuuuuuuu", options, tempMasterShortAddress, tempMasterTxChannel,    \
1644                                   gpdSrcId, gpdIeee, endpoint, gpdCommandId, gpdCommandPayload);
1645
1646 /** @brief Command description for GpTranslationTableUpdate
1647  *
1648  * Command: GpTranslationTableUpdate
1649  * @param options GpTranslationTableUpdateOption
1650  * @param gpdSrcId INT32U
1651  * @param gpdIeee IEEE_ADDRESS
1652  * @param endpoint INT8U
1653  * @param translations GpTranslationTableUpdateTranslation []
1654  * @param translationsLen int
1655  */
1656 #define emberAfFillCommandGreen                                                                                                    \
1657     PowerClusterGpTranslationTableUpdate(options, gpdSrcId, gpdIeee, endpoint, translations, translationsLen)                      \
1658         emberAfFillExternalBuffer(mask,                                                                                            \
1659                                                                                                                                    \
1660                                   ZCL_GP_TRANSLATION_TABLE_UPDATE_COMMAND_ID, "uuuub", options, gpdSrcId, gpdIeee, endpoint,       \
1661                                   translations, translationsLen);
1662
1663 /** @brief Command description for GpTranslationTableRequest
1664  *
1665  * Command: GpTranslationTableRequest
1666  * @param startIndex INT8U
1667  * @param status GpTranslationTableResponseStatus
1668  * @param options GpTranslationTableResponseOption
1669  * @param totalNumberOfEntries INT8U
1670  * @param startIndex INT8U
1671  * @param entriesCount INT8U
1672  * @param translationTableList INT8U []
1673  * @param translationTableListLen int
1674  */
1675 #define emberAfFillCommandGreen                                                                                                    \
1676     PowerClusterGpTranslationTableRequest(startIndex, status, options, totalNumberOfEntries, startIndex, entriesCount,             \
1677                                           translationTableList, translationTableListLen)                                           \
1678         emberAfFillExternalBuffer(mask,                                                                                            \
1679                                                                                                                                    \
1680                                   ZCL_GP_TRANSLATION_TABLE_REQUEST_COMMAND_ID, "uuuuuub", startIndex, status, options,             \
1681                                   totalNumberOfEntries, startIndex, entriesCount, translationTableList, translationTableListLen);
1682
1683 /** @brief Command description for GpPairingConfiguration
1684  *
1685  * Command: GpPairingConfiguration
1686  * @param actions GpPairingConfigurationActions
1687  * @param options GpPairingConfigurationOption
1688  * @param gpdSrcId INT32U
1689  * @param gpdIeee IEEE_ADDRESS
1690  * @param endpoint INT8U
1691  * @param deviceId INT8U
1692  * @param groupListCount INT8U
1693  * @param groupList GpPairingConfigurationGroupList []
1694  * @param groupListLen int
1695  * @param gpdAssignedAlias INT16U
1696  * @param groupcastRadius INT8U
1697  * @param securityOptions INT8U
1698  * @param gpdSecurityFrameCounter INT32U
1699  * @param gpdSecurityKey SECURITY_KEY
1700  * @param numberOfPairedEndpoints INT8U
1701  * @param pairedEndpoints INT8U []
1702  * @param pairedEndpointsLen int
1703  * @param applicationInformation GpApplicationInformation
1704  * @param manufacturerId INT16U
1705  * @param modeId INT16U
1706  * @param numberOfGpdCommands INT8U
1707  * @param gpdCommandIdList INT8U []
1708  * @param gpdCommandIdListLen int
1709  * @param clusterIdListCount INT8U
1710  * @param clusterListServer INT16U []
1711  * @param clusterListServerLen int
1712  * @param clusterListClient INT16U []
1713  * @param clusterListClientLen int
1714  * @param switchInformationLength INT8U
1715  * @param switchConfiguration INT8U
1716  * @param currentContactStatus INT8U
1717  * @param totalNumberOfReports INT8U
1718  * @param numberOfReports INT8U
1719  * @param reportDescriptor INT8U []
1720  * @param reportDescriptorLen int
1721  */
1722 #define emberAfFillCommandGreen                                                                                                    \
1723     PowerClusterGpPairingConfiguration(                                                                                            \
1724         actions, options, gpdSrcId, gpdIeee, endpoint, deviceId, groupListCount, groupList, groupListLen, gpdAssignedAlias,        \
1725         groupcastRadius, securityOptions, gpdSecurityFrameCounter, gpdSecurityKey, numberOfPairedEndpoints, pairedEndpoints,       \
1726         pairedEndpointsLen, applicationInformation, manufacturerId, modeId, numberOfGpdCommands, gpdCommandIdList,                 \
1727         gpdCommandIdListLen, clusterIdListCount, clusterListServer, clusterListServerLen, clusterListClient, clusterListClientLen, \
1728         switchInformationLength, switchConfiguration, currentContactStatus, totalNumberOfReports, numberOfReports,                 \
1729         reportDescriptor, reportDescriptorLen)                                                                                     \
1730         emberAfFillExternalBuffer(mask,                                                                                            \
1731                                                                                                                                    \
1732                                   ZCL_GP_PAIRING_CONFIGURATION_COMMAND_ID, "uuuuuuubuuuuuubuuuububbuuuuub", actions, options,      \
1733                                   gpdSrcId, gpdIeee, endpoint, deviceId, groupListCount, groupList, groupListLen,                  \
1734                                   gpdAssignedAlias, groupcastRadius, securityOptions, gpdSecurityFrameCounter, gpdSecurityKey,     \
1735                                   numberOfPairedEndpoints, pairedEndpoints, pairedEndpointsLen, applicationInformation,            \
1736                                   manufacturerId, modeId, numberOfGpdCommands, gpdCommandIdList, gpdCommandIdListLen,              \
1737                                   clusterIdListCount, clusterListServer, clusterListServerLen, clusterListClient,                  \
1738                                   clusterListClientLen, switchInformationLength, switchConfiguration, currentContactStatus,        \
1739                                   totalNumberOfReports, numberOfReports, reportDescriptor, reportDescriptorLen);
1740
1741 /** @brief Command description for GpSinkTableRequest
1742  *
1743  * Command: GpSinkTableRequest
1744  * @param options GpSinkTableRequestOptions
1745  * @param status ENUM8
1746  * @param gpdSrcId INT32U
1747  * @param totalNumberofNonEmptySinkTableEntries INT8U
1748  * @param gpdIeee INT64U
1749  * @param startIndex INT8U
1750  * @param endpoint INT8U
1751  * @param sinkTableEntriesCount INT8U
1752  * @param index INT8U
1753  * @param sinkTableEntries INT8U []
1754  * @param sinkTableEntriesLen int
1755  */
1756 #define emberAfFillCommandGreen                                                                                                    \
1757     PowerClusterGpSinkTableRequest(options, status, gpdSrcId, totalNumberofNonEmptySinkTableEntries, gpdIeee, startIndex,          \
1758                                    endpoint, sinkTableEntriesCount, index, sinkTableEntries, sinkTableEntriesLen)                  \
1759         emberAfFillExternalBuffer(mask,                                                                                            \
1760                                                                                                                                    \
1761                                   ZCL_GP_SINK_TABLE_REQUEST_COMMAND_ID, "uuuuuuuuub", options, status, gpdSrcId,                   \
1762                                   totalNumberofNonEmptySinkTableEntries, gpdIeee, startIndex, endpoint, sinkTableEntriesCount,     \
1763                                   index, sinkTableEntries, sinkTableEntriesLen);
1764
1765 /** @brief Command description for GpProxyTableResponse
1766  *
1767  * Command: GpProxyTableResponse
1768  * @param status GpProxyTableResponseStatus
1769  * @param options GpProxyTableRequestOptions
1770  * @param totalNumberOfNonEmptyProxyTableEntries INT8U
1771  * @param gpdSrcId INT32U
1772  * @param startIndex INT8U
1773  * @param gpdIeee INT64U
1774  * @param entriesCount INT8U
1775  * @param endpoint INT8U
1776  * @param proxyTableEntries INT8U []
1777  * @param proxyTableEntriesLen int
1778  * @param index INT8U
1779  */
1780 #define emberAfFillCommandGreen                                                                                                    \
1781     PowerClusterGpProxyTableResponse(status, options, totalNumberOfNonEmptyProxyTableEntries, gpdSrcId, startIndex, gpdIeee,       \
1782                                      entriesCount, endpoint, proxyTableEntries, proxyTableEntriesLen, index)                       \
1783         emberAfFillExternalBuffer(mask,                                                                                            \
1784                                                                                                                                    \
1785                                   ZCL_GP_PROXY_TABLE_RESPONSE_COMMAND_ID, "uuuuuuuubu", status, options,                           \
1786                                   totalNumberOfNonEmptyProxyTableEntries, gpdSrcId, startIndex, gpdIeee, entriesCount, endpoint,   \
1787                                   proxyTableEntries, proxyTableEntriesLen, index);
1788
1789 /** @brief Command description for StartUp
1790  *
1791  * Command: StartUp
1792  */
1793 #define emberAfFillCommandBasicClusterStartUp()                                                                                    \
1794     emberAfFillExternalBuffer(mask,                                                                                                \
1795                                                                                                                                    \
1796                               ZCL_START_UP_COMMAND_ID, "", );
1797
1798 /** @brief Command description for ShutDown
1799  *
1800  * Command: ShutDown
1801  */
1802 #define emberAfFillCommandBasicClusterShutDown()                                                                                   \
1803     emberAfFillExternalBuffer(mask,                                                                                                \
1804                                                                                                                                    \
1805                               ZCL_SHUT_DOWN_COMMAND_ID, "", );
1806
1807 /** @brief Command description for Leave
1808  *
1809  * Command: Leave
1810  */
1811 #define emberAfFillCommandBasicClusterLeave()                                                                                      \
1812     emberAfFillExternalBuffer(mask,                                                                                                \
1813                                                                                                                                    \
1814                               ZCL_LEAVE_COMMAND_ID, "", );
1815
1816 /** @brief Command description for SetFabric
1817  *
1818  * Command: SetFabric
1819  * @param fabricId OCTET_STRING
1820  * @param fabricSecret OCTET_STRING
1821  * @param breadcrumb INT64U
1822  * @param timeoutMs INT32U
1823  */
1824 #define emberAfFillCommandGeneral                                                                                                  \
1825     CommissioningClusterSetFabric(fabricId, fabricSecret, breadcrumb, timeoutMs)                                                   \
1826         emberAfFillExternalBuffer(mask,                                                                                            \
1827                                                                                                                                    \
1828                                   ZCL_SET_FABRIC_COMMAND_ID, "uuuu", fabricId, fabricSecret, breadcrumb, timeoutMs);
1829
1830 /** @brief Command description for SetFabricResponse
1831  *
1832  * Command: SetFabricResponse
1833  * @param errorCode INT8U
1834  * @param debugText CHAR_STRING
1835  */
1836 #define emberAfFillCommandGeneral                                                                                                  \
1837     CommissioningClusterSetFabricResponse(errorCode, debugText)                                                                    \
1838         emberAfFillExternalBuffer(mask,                                                                                            \
1839                                                                                                                                    \
1840                                   ZCL_SET_FABRIC_RESPONSE_COMMAND_ID, "uu", errorCode, debugText);
1841
1842 /** @brief Command description for ArmFailSafe
1843  *
1844  * Command: ArmFailSafe
1845  * @param expiryLengthSeconds INT16U
1846  * @param breadcrumb INT64U
1847  * @param timeoutMs INT32U
1848  */
1849 #define emberAfFillCommandGeneral                                                                                                  \
1850     CommissioningClusterArmFailSafe(expiryLengthSeconds, breadcrumb, timeoutMs)                                                    \
1851         emberAfFillExternalBuffer(mask,                                                                                            \
1852                                                                                                                                    \
1853                                   ZCL_ARM_FAIL_SAFE_COMMAND_ID, "uuu", expiryLengthSeconds, breadcrumb, timeoutMs);
1854
1855 /** @brief Command description for ArmFailSafeResponse
1856  *
1857  * Command: ArmFailSafeResponse
1858  * @param errorCode INT8U
1859  * @param debugText CHAR_STRING
1860  */
1861 #define emberAfFillCommandGeneral                                                                                                  \
1862     CommissioningClusterArmFailSafeResponse(errorCode, debugText)                                                                  \
1863         emberAfFillExternalBuffer(mask,                                                                                            \
1864                                                                                                                                    \
1865                                   ZCL_ARM_FAIL_SAFE_RESPONSE_COMMAND_ID, "uu", errorCode, debugText);
1866
1867 /** @brief Command description for SetRegulatoryConfig
1868  *
1869  * Command: SetRegulatoryConfig
1870  * @param location RegulatoryLocationType
1871  * @param countryCode CHAR_STRING
1872  * @param breadcrumb INT64U
1873  * @param timeoutMs INT32U
1874  */
1875 #define emberAfFillCommandGeneral                                                                                                  \
1876     CommissioningClusterSetRegulatoryConfig(location, countryCode, breadcrumb, timeoutMs)                                          \
1877         emberAfFillExternalBuffer(mask,                                                                                            \
1878                                                                                                                                    \
1879                                   ZCL_SET_REGULATORY_CONFIG_COMMAND_ID, "uuuu", location, countryCode, breadcrumb, timeoutMs);
1880
1881 /** @brief Command description for SetRegulatoryConfigResponse
1882  *
1883  * Command: SetRegulatoryConfigResponse
1884  * @param errorCode INT8U
1885  * @param debugText CHAR_STRING
1886  */
1887 #define emberAfFillCommandGeneral                                                                                                  \
1888     CommissioningClusterSetRegulatoryConfigResponse(errorCode, debugText)                                                          \
1889         emberAfFillExternalBuffer(mask,                                                                                            \
1890                                                                                                                                    \
1891                                   ZCL_SET_REGULATORY_CONFIG_RESPONSE_COMMAND_ID, "uu", errorCode, debugText);
1892
1893 /** @brief Command description for CommissioningComplete
1894  *
1895  * Command: CommissioningComplete
1896  */
1897 #define emberAfFillCommandGeneral                                                                                                  \
1898     CommissioningClusterCommissioningComplete() emberAfFillExternalBuffer(mask,                                                    \
1899                                                                                                                                    \
1900                                                                           ZCL_COMMISSIONING_COMPLETE_COMMAND_ID, "", );
1901
1902 /** @brief Command description for CommissioningCompleteResponse
1903  *
1904  * Command: CommissioningCompleteResponse
1905  * @param errorCode INT8U
1906  * @param debugText CHAR_STRING
1907  */
1908 #define emberAfFillCommandGeneral                                                                                                  \
1909     CommissioningClusterCommissioningCompleteResponse(errorCode, debugText)                                                        \
1910         emberAfFillExternalBuffer(mask,                                                                                            \
1911                                                                                                                                    \
1912                                   ZCL_COMMISSIONING_COMPLETE_RESPONSE_COMMAND_ID, "uu", errorCode, debugText);
1913
1914 /** @brief Command description for ScanNetworks
1915  *
1916  * Command: ScanNetworks
1917  * @param ssid OCTET_STRING
1918  * @param breadcrumb INT64U
1919  * @param timeoutMs INT32U
1920  */
1921 #define emberAfFillCommandNetwork                                                                                                  \
1922     CommissioningClusterScanNetworks(ssid, breadcrumb, timeoutMs)                                                                  \
1923         emberAfFillExternalBuffer(mask,                                                                                            \
1924                                                                                                                                    \
1925                                   ZCL_SCAN_NETWORKS_COMMAND_ID, "uuu", ssid, breadcrumb, timeoutMs);
1926
1927 /** @brief Command description for ScanNetworksResponse
1928  *
1929  * Command: ScanNetworksResponse
1930  * @param errorCode INT8U
1931  * @param debugText CHAR_STRING
1932  * @param wifiScanResults WiFiInterfaceScanResult []
1933  * @param wifiScanResultsLen int
1934  * @param threadScanResults ThreadInterfaceScanResult []
1935  * @param threadScanResultsLen int
1936  */
1937 #define emberAfFillCommandNetwork                                                                                                  \
1938     CommissioningClusterScanNetworksResponse(errorCode, debugText, wifiScanResults, wifiScanResultsLen, threadScanResults,         \
1939                                              threadScanResultsLen)                                                                 \
1940         emberAfFillExternalBuffer(mask,                                                                                            \
1941                                                                                                                                    \
1942                                   ZCL_SCAN_NETWORKS_RESPONSE_COMMAND_ID, "uubb", errorCode, debugText, wifiScanResults,            \
1943                                   wifiScanResultsLen, threadScanResults, threadScanResultsLen);
1944
1945 /** @brief Command description for AddWiFiNetwork
1946  *
1947  * Command: AddWiFiNetwork
1948  * @param ssid OCTET_STRING
1949  * @param credentials OCTET_STRING
1950  * @param breadcrumb INT64U
1951  * @param timeoutMs INT32U
1952  */
1953 #define emberAfFillCommandNetwork                                                                                                  \
1954     CommissioningClusterAddWiFiNetwork(ssid, credentials, breadcrumb, timeoutMs)                                                   \
1955         emberAfFillExternalBuffer(mask,                                                                                            \
1956                                                                                                                                    \
1957                                   ZCL_ADD_WI_FI_NETWORK_COMMAND_ID, "uuuu", ssid, credentials, breadcrumb, timeoutMs);
1958
1959 /** @brief Command description for AddWiFiNetworkResponse
1960  *
1961  * Command: AddWiFiNetworkResponse
1962  * @param errorCode INT8U
1963  * @param debugText CHAR_STRING
1964  */
1965 #define emberAfFillCommandNetwork                                                                                                  \
1966     CommissioningClusterAddWiFiNetworkResponse(errorCode, debugText)                                                               \
1967         emberAfFillExternalBuffer(mask,                                                                                            \
1968                                                                                                                                    \
1969                                   ZCL_ADD_WI_FI_NETWORK_RESPONSE_COMMAND_ID, "uu", errorCode, debugText);
1970
1971 /** @brief Command description for UpdateWiFiNetwork
1972  *
1973  * Command: UpdateWiFiNetwork
1974  * @param ssid OCTET_STRING
1975  * @param credentials OCTET_STRING
1976  * @param breadcrumb INT64U
1977  * @param timeoutMs INT32U
1978  */
1979 #define emberAfFillCommandNetwork                                                                                                  \
1980     CommissioningClusterUpdateWiFiNetwork(ssid, credentials, breadcrumb, timeoutMs)                                                \
1981         emberAfFillExternalBuffer(mask,                                                                                            \
1982                                                                                                                                    \
1983                                   ZCL_UPDATE_WI_FI_NETWORK_COMMAND_ID, "uuuu", ssid, credentials, breadcrumb, timeoutMs);
1984
1985 /** @brief Command description for UpdateWiFiNetworkResponse
1986  *
1987  * Command: UpdateWiFiNetworkResponse
1988  * @param errorCode INT8U
1989  * @param debugText CHAR_STRING
1990  */
1991 #define emberAfFillCommandNetwork                                                                                                  \
1992     CommissioningClusterUpdateWiFiNetworkResponse(errorCode, debugText)                                                            \
1993         emberAfFillExternalBuffer(mask,                                                                                            \
1994                                                                                                                                    \
1995                                   ZCL_UPDATE_WI_FI_NETWORK_RESPONSE_COMMAND_ID, "uu", errorCode, debugText);
1996
1997 /** @brief Command description for AddThreadNetwork
1998  *
1999  * Command: AddThreadNetwork
2000  * @param operationalDataset OCTET_STRING
2001  * @param breadcrumb INT64U
2002  * @param timeoutMs INT32U
2003  */
2004 #define emberAfFillCommandNetwork                                                                                                  \
2005     CommissioningClusterAddThreadNetwork(operationalDataset, breadcrumb, timeoutMs)                                                \
2006         emberAfFillExternalBuffer(mask,                                                                                            \
2007                                                                                                                                    \
2008                                   ZCL_ADD_THREAD_NETWORK_COMMAND_ID, "uuu", operationalDataset, breadcrumb, timeoutMs);
2009
2010 /** @brief Command description for AddThreadNetworkResponse
2011  *
2012  * Command: AddThreadNetworkResponse
2013  * @param errorCode INT8U
2014  * @param debugText CHAR_STRING
2015  */
2016 #define emberAfFillCommandNetwork                                                                                                  \
2017     CommissioningClusterAddThreadNetworkResponse(errorCode, debugText)                                                             \
2018         emberAfFillExternalBuffer(mask,                                                                                            \
2019                                                                                                                                    \
2020                                   ZCL_ADD_THREAD_NETWORK_RESPONSE_COMMAND_ID, "uu", errorCode, debugText);
2021
2022 /** @brief Command description for UpdateThreadNetwork
2023  *
2024  * Command: UpdateThreadNetwork
2025  * @param operationalDataset OCTET_STRING
2026  * @param breadcrumb INT64U
2027  * @param timeoutMs INT32U
2028  */
2029 #define emberAfFillCommandNetwork                                                                                                  \
2030     CommissioningClusterUpdateThreadNetwork(operationalDataset, breadcrumb, timeoutMs)                                             \
2031         emberAfFillExternalBuffer(mask,                                                                                            \
2032                                                                                                                                    \
2033                                   ZCL_UPDATE_THREAD_NETWORK_COMMAND_ID, "uuu", operationalDataset, breadcrumb, timeoutMs);
2034
2035 /** @brief Command description for UpdateThreadNetworkResponse
2036  *
2037  * Command: UpdateThreadNetworkResponse
2038  * @param errorCode INT8U
2039  * @param debugText CHAR_STRING
2040  */
2041 #define emberAfFillCommandNetwork                                                                                                  \
2042     CommissioningClusterUpdateThreadNetworkResponse(errorCode, debugText)                                                          \
2043         emberAfFillExternalBuffer(mask,                                                                                            \
2044                                                                                                                                    \
2045                                   ZCL_UPDATE_THREAD_NETWORK_RESPONSE_COMMAND_ID, "uu", errorCode, debugText);
2046
2047 /** @brief Command description for RemoveNetwork
2048  *
2049  * Command: RemoveNetwork
2050  * @param NetworkID OCTET_STRING
2051  * @param Breadcrumb INT64U
2052  * @param TimeoutMs INT32U
2053  */
2054 #define emberAfFillCommandNetwork                                                                                                  \
2055     CommissioningClusterRemoveNetwork(NetworkID, Breadcrumb, TimeoutMs)                                                            \
2056         emberAfFillExternalBuffer(mask,                                                                                            \
2057                                                                                                                                    \
2058                                   ZCL_REMOVE_NETWORK_COMMAND_ID, "uuu", NetworkID, Breadcrumb, TimeoutMs);
2059
2060 /** @brief Command description for RemoveNetworkResponse
2061  *
2062  * Command: RemoveNetworkResponse
2063  * @param errorCode INT8U
2064  * @param debugText CHAR_STRING
2065  */
2066 #define emberAfFillCommandNetwork                                                                                                  \
2067     CommissioningClusterRemoveNetworkResponse(errorCode, debugText)                                                                \
2068         emberAfFillExternalBuffer(mask,                                                                                            \
2069                                                                                                                                    \
2070                                   ZCL_REMOVE_NETWORK_RESPONSE_COMMAND_ID, "uu", errorCode, debugText);
2071
2072 /** @brief Command description for EnableNetwork
2073  *
2074  * Command: EnableNetwork
2075  * @param networkID OCTET_STRING
2076  * @param breadcrumb INT64U
2077  * @param timeoutMs INT32U
2078  */
2079 #define emberAfFillCommandNetwork                                                                                                  \
2080     CommissioningClusterEnableNetwork(networkID, breadcrumb, timeoutMs)                                                            \
2081         emberAfFillExternalBuffer(mask,                                                                                            \
2082                                                                                                                                    \
2083                                   ZCL_ENABLE_NETWORK_COMMAND_ID, "uuu", networkID, breadcrumb, timeoutMs);
2084
2085 /** @brief Command description for EnableNetworkResponse
2086  *
2087  * Command: EnableNetworkResponse
2088  * @param errorCode INT8U
2089  * @param debugText CHAR_STRING
2090  */
2091 #define emberAfFillCommandNetwork                                                                                                  \
2092     CommissioningClusterEnableNetworkResponse(errorCode, debugText)                                                                \
2093         emberAfFillExternalBuffer(mask,                                                                                            \
2094                                                                                                                                    \
2095                                   ZCL_ENABLE_NETWORK_RESPONSE_COMMAND_ID, "uu", errorCode, debugText);
2096
2097 /** @brief Command description for DisableNetwork
2098  *
2099  * Command: DisableNetwork
2100  * @param networkID OCTET_STRING
2101  * @param breadcrumb INT64U
2102  * @param timeoutMs INT32U
2103  */
2104 #define emberAfFillCommandNetwork                                                                                                  \
2105     CommissioningClusterDisableNetwork(networkID, breadcrumb, timeoutMs)                                                           \
2106         emberAfFillExternalBuffer(mask,                                                                                            \
2107                                                                                                                                    \
2108                                   ZCL_DISABLE_NETWORK_COMMAND_ID, "uuu", networkID, breadcrumb, timeoutMs);
2109
2110 /** @brief Command description for DisableNetworkResponse
2111  *
2112  * Command: DisableNetworkResponse
2113  * @param errorCode INT8U
2114  * @param debugText CHAR_STRING
2115  */
2116 #define emberAfFillCommandNetwork                                                                                                  \
2117     CommissioningClusterDisableNetworkResponse(errorCode, debugText)                                                               \
2118         emberAfFillExternalBuffer(mask,                                                                                            \
2119                                                                                                                                    \
2120                                   ZCL_DISABLE_NETWORK_RESPONSE_COMMAND_ID, "uu", errorCode, debugText);
2121
2122 /** @brief Command description for GetLastNetworkCommissioningResult
2123  *
2124  * Command: GetLastNetworkCommissioningResult
2125  * @param timeoutMs INT32U
2126  */
2127 #define emberAfFillCommandNetwork                                                                                                  \
2128     CommissioningClusterGetLastNetworkCommissioningResult(timeoutMs)                                                               \
2129         emberAfFillExternalBuffer(mask,                                                                                            \
2130                                                                                                                                    \
2131                                   ZCL_GET_LAST_NETWORK_COMMISSIONING_RESULT_COMMAND_ID, "u", timeoutMs);
2132
2133 /** @brief Command description for LockDoor
2134  *
2135  * Command: LockDoor
2136  * @param PIN CHAR_STRING
2137  * @param status INT8U
2138  */
2139 #define emberAfFillCommandDoor                                                                                                     \
2140     LockClusterLockDoor(PIN, status) emberAfFillExternalBuffer(mask,                                                               \
2141                                                                                                                                    \
2142                                                                ZCL_LOCK_DOOR_COMMAND_ID, "uu", PIN, status);
2143
2144 /** @brief Command description for UnlockDoor
2145  *
2146  * Command: UnlockDoor
2147  * @param PIN CHAR_STRING
2148  * @param status INT8U
2149  */
2150 #define emberAfFillCommandDoor                                                                                                     \
2151     LockClusterUnlockDoor(PIN, status) emberAfFillExternalBuffer(mask,                                                             \
2152                                                                                                                                    \
2153                                                                  ZCL_UNLOCK_DOOR_COMMAND_ID, "uu", PIN, status);
2154
2155 /** @brief Command description for Toggle
2156  *
2157  * Command: Toggle
2158  * @param pin CHAR_STRING
2159  * @param status INT8U
2160  */
2161 #define emberAfFillCommandDoor                                                                                                     \
2162     LockClusterToggle(pin, status) emberAfFillExternalBuffer(mask,                                                                 \
2163                                                                                                                                    \
2164                                                              ZCL_TOGGLE_COMMAND_ID, "uu", pin, status);
2165
2166 /** @brief Command description for UnlockWithTimeout
2167  *
2168  * Command: UnlockWithTimeout
2169  * @param timeoutInSeconds INT16U
2170  * @param status INT8U
2171  * @param pin CHAR_STRING
2172  */
2173 #define emberAfFillCommandDoor                                                                                                     \
2174     LockClusterUnlockWithTimeout(timeoutInSeconds, status, pin)                                                                    \
2175         emberAfFillExternalBuffer(mask,                                                                                            \
2176                                                                                                                                    \
2177                                   ZCL_UNLOCK_WITH_TIMEOUT_COMMAND_ID, "uuu", timeoutInSeconds, status, pin);
2178
2179 /** @brief Command description for GetLogRecord
2180  *
2181  * Command: GetLogRecord
2182  * @param logIndex INT16U
2183  * @param logEntryId INT16U
2184  * @param timestamp INT32U
2185  * @param eventType ENUM8
2186  * @param source INT8U
2187  * @param eventIdOrAlarmCode INT8U
2188  * @param userId INT16U
2189  * @param pin CHAR_STRING
2190  */
2191 #define emberAfFillCommandDoor                                                                                                     \
2192     LockClusterGetLogRecord(logIndex, logEntryId, timestamp, eventType, source, eventIdOrAlarmCode, userId, pin)                   \
2193         emberAfFillExternalBuffer(mask,                                                                                            \
2194                                                                                                                                    \
2195                                   ZCL_GET_LOG_RECORD_COMMAND_ID, "uuuuuuuu", logIndex, logEntryId, timestamp, eventType, source,   \
2196                                   eventIdOrAlarmCode, userId, pin);
2197
2198 /** @brief Command description for SetPin
2199  *
2200  * Command: SetPin
2201  * @param userId INT16U
2202  * @param status DoorLockSetPinOrIdStatus
2203  * @param userStatus DoorLockUserStatus
2204  * @param userType DoorLockUserType
2205  * @param pin CHAR_STRING
2206  */
2207 #define emberAfFillCommandDoor                                                                                                     \
2208     LockClusterSetPin(userId, status, userStatus, userType, pin)                                                                   \
2209         emberAfFillExternalBuffer(mask,                                                                                            \
2210                                                                                                                                    \
2211                                   ZCL_SET_PIN_COMMAND_ID, "uuuuu", userId, status, userStatus, userType, pin);
2212
2213 /** @brief Command description for GetPin
2214  *
2215  * Command: GetPin
2216  * @param userId INT16U
2217  * @param userId INT16U
2218  * @param userStatus DoorLockUserStatus
2219  * @param userType DoorLockUserType
2220  * @param pin CHAR_STRING
2221  */
2222 #define emberAfFillCommandDoor                                                                                                     \
2223     LockClusterGetPin(userId, userId, userStatus, userType, pin)                                                                   \
2224         emberAfFillExternalBuffer(mask,                                                                                            \
2225                                                                                                                                    \
2226                                   ZCL_GET_PIN_COMMAND_ID, "uuuuu", userId, userId, userStatus, userType, pin);
2227
2228 /** @brief Command description for ClearPin
2229  *
2230  * Command: ClearPin
2231  * @param userId INT16U
2232  * @param status INT8U
2233  */
2234 #define emberAfFillCommandDoor                                                                                                     \
2235     LockClusterClearPin(userId, status) emberAfFillExternalBuffer(mask,                                                            \
2236                                                                                                                                    \
2237                                                                   ZCL_CLEAR_PIN_COMMAND_ID, "uu", userId, status);
2238
2239 /** @brief Command description for ClearAllPins
2240  *
2241  * Command: ClearAllPins
2242  * @param status INT8U
2243  */
2244 #define emberAfFillCommandDoor                                                                                                     \
2245     LockClusterClearAllPins(status) emberAfFillExternalBuffer(mask,                                                                \
2246                                                                                                                                    \
2247                                                               ZCL_CLEAR_ALL_PINS_COMMAND_ID, "u", status);
2248
2249 /** @brief Command description for SetUserStatus
2250  *
2251  * Command: SetUserStatus
2252  * @param userId INT16U
2253  * @param status INT8U
2254  * @param userStatus INT8U
2255  */
2256 #define emberAfFillCommandDoor                                                                                                     \
2257     LockClusterSetUserStatus(userId, status, userStatus)                                                                           \
2258         emberAfFillExternalBuffer(mask,                                                                                            \
2259                                                                                                                                    \
2260                                   ZCL_SET_USER_STATUS_COMMAND_ID, "uuu", userId, status, userStatus);
2261
2262 /** @brief Command description for GetUserStatus
2263  *
2264  * Command: GetUserStatus
2265  * @param userId INT16U
2266  * @param userId INT16U
2267  * @param status INT8U
2268  */
2269 #define emberAfFillCommandDoor                                                                                                     \
2270     LockClusterGetUserStatus(userId, userId, status)                                                                               \
2271         emberAfFillExternalBuffer(mask,                                                                                            \
2272                                                                                                                                    \
2273                                   ZCL_GET_USER_STATUS_COMMAND_ID, "uuu", userId, userId, status);
2274
2275 /** @brief Command description for SetWeekdaySchedule
2276  *
2277  * Command: SetWeekdaySchedule
2278  * @param scheduleId INT8U
2279  * @param status INT8U
2280  * @param userId INT16U
2281  * @param daysMask DoorLockDayOfWeek
2282  * @param startHour INT8U
2283  * @param startMinute INT8U
2284  * @param endHour INT8U
2285  * @param endMinute INT8U
2286  */
2287 #define emberAfFillCommandDoor                                                                                                     \
2288     LockClusterSetWeekdaySchedule(scheduleId, status, userId, daysMask, startHour, startMinute, endHour, endMinute)                \
2289         emberAfFillExternalBuffer(mask,                                                                                            \
2290                                                                                                                                    \
2291                                   ZCL_SET_WEEKDAY_SCHEDULE_COMMAND_ID, "uuuuuuuu", scheduleId, status, userId, daysMask,           \
2292                                   startHour, startMinute, endHour, endMinute);
2293
2294 /** @brief Command description for GetWeekdaySchedule
2295  *
2296  * Command: GetWeekdaySchedule
2297  * @param scheduleId INT8U
2298  * @param scheduleId INT8U
2299  * @param userId INT16U
2300  * @param userId INT16U
2301  * @param status INT8U
2302  * @param daysMask INT8U
2303  * @param startHour INT8U
2304  * @param startMinute INT8U
2305  * @param endHour INT8U
2306  * @param endMinute INT8U
2307  */
2308 #define emberAfFillCommandDoor                                                                                                     \
2309     LockClusterGetWeekdaySchedule(scheduleId, scheduleId, userId, userId, status, daysMask, startHour, startMinute, endHour,       \
2310                                   endMinute)                                                                                       \
2311         emberAfFillExternalBuffer(mask,                                                                                            \
2312                                                                                                                                    \
2313                                   ZCL_GET_WEEKDAY_SCHEDULE_COMMAND_ID, "uuuuuuuuuu", scheduleId, scheduleId, userId, userId,       \
2314                                   status, daysMask, startHour, startMinute, endHour, endMinute);
2315
2316 /** @brief Command description for ClearWeekdaySchedule
2317  *
2318  * Command: ClearWeekdaySchedule
2319  * @param scheduleId INT8U
2320  * @param status INT8U
2321  * @param userId INT16U
2322  */
2323 #define emberAfFillCommandDoor                                                                                                     \
2324     LockClusterClearWeekdaySchedule(scheduleId, status, userId)                                                                    \
2325         emberAfFillExternalBuffer(mask,                                                                                            \
2326                                                                                                                                    \
2327                                   ZCL_CLEAR_WEEKDAY_SCHEDULE_COMMAND_ID, "uuu", scheduleId, status, userId);
2328
2329 /** @brief Command description for SetYeardaySchedule
2330  *
2331  * Command: SetYeardaySchedule
2332  * @param scheduleId INT8U
2333  * @param status INT8U
2334  * @param userId INT16U
2335  * @param localStartTime INT32U
2336  * @param localEndTime INT32U
2337  */
2338 #define emberAfFillCommandDoor                                                                                                     \
2339     LockClusterSetYeardaySchedule(scheduleId, status, userId, localStartTime, localEndTime) emberAfFillExternalBuffer(             \
2340         mask,                                                                                                                      \
2341                                                                                                                                    \
2342         ZCL_SET_YEARDAY_SCHEDULE_COMMAND_ID, "uuuuu", scheduleId, status, userId, localStartTime, localEndTime);
2343
2344 /** @brief Command description for GetYeardaySchedule
2345  *
2346  * Command: GetYeardaySchedule
2347  * @param scheduleId INT8U
2348  * @param scheduleId INT8U
2349  * @param userId INT16U
2350  * @param userId INT16U
2351  * @param status INT8U
2352  * @param localStartTime INT32U
2353  * @param localEndTime INT32U
2354  */
2355 #define emberAfFillCommandDoor                                                                                                     \
2356     LockClusterGetYeardaySchedule(scheduleId, scheduleId, userId, userId, status, localStartTime, localEndTime)                    \
2357         emberAfFillExternalBuffer(mask,                                                                                            \
2358                                                                                                                                    \
2359                                   ZCL_GET_YEARDAY_SCHEDULE_COMMAND_ID, "uuuuuuu", scheduleId, scheduleId, userId, userId, status,  \
2360                                   localStartTime, localEndTime);
2361
2362 /** @brief Command description for ClearYeardaySchedule
2363  *
2364  * Command: ClearYeardaySchedule
2365  * @param scheduleId INT8U
2366  * @param status INT8U
2367  * @param userId INT16U
2368  */
2369 #define emberAfFillCommandDoor                                                                                                     \
2370     LockClusterClearYeardaySchedule(scheduleId, status, userId)                                                                    \
2371         emberAfFillExternalBuffer(mask,                                                                                            \
2372                                                                                                                                    \
2373                                   ZCL_CLEAR_YEARDAY_SCHEDULE_COMMAND_ID, "uuu", scheduleId, status, userId);
2374
2375 /** @brief Command description for SetHolidaySchedule
2376  *
2377  * Command: SetHolidaySchedule
2378  * @param scheduleId INT8U
2379  * @param status INT8U
2380  * @param localStartTime INT32U
2381  * @param localEndTime INT32U
2382  * @param operatingModeDuringHoliday ENUM8
2383  */
2384 #define emberAfFillCommandDoor                                                                                                     \
2385     LockClusterSetHolidaySchedule(scheduleId, status, localStartTime, localEndTime, operatingModeDuringHoliday)                    \
2386         emberAfFillExternalBuffer(mask,                                                                                            \
2387                                                                                                                                    \
2388                                   ZCL_SET_HOLIDAY_SCHEDULE_COMMAND_ID, "uuuuu", scheduleId, status, localStartTime, localEndTime,  \
2389                                   operatingModeDuringHoliday);
2390
2391 /** @brief Command description for GetHolidaySchedule
2392  *
2393  * Command: GetHolidaySchedule
2394  * @param scheduleId INT8U
2395  * @param scheduleId INT8U
2396  * @param status INT8U
2397  * @param localStartTime INT32U
2398  * @param localEndTime INT32U
2399  * @param operatingModeDuringHoliday ENUM8
2400  */
2401 #define emberAfFillCommandDoor                                                                                                     \
2402     LockClusterGetHolidaySchedule(scheduleId, scheduleId, status, localStartTime, localEndTime, operatingModeDuringHoliday)        \
2403         emberAfFillExternalBuffer(mask,                                                                                            \
2404                                                                                                                                    \
2405                                   ZCL_GET_HOLIDAY_SCHEDULE_COMMAND_ID, "uuuuuu", scheduleId, scheduleId, status, localStartTime,   \
2406                                   localEndTime, operatingModeDuringHoliday);
2407
2408 /** @brief Command description for ClearHolidaySchedule
2409  *
2410  * Command: ClearHolidaySchedule
2411  * @param scheduleId INT8U
2412  * @param status INT8U
2413  */
2414 #define emberAfFillCommandDoor                                                                                                     \
2415     LockClusterClearHolidaySchedule(scheduleId, status)                                                                            \
2416         emberAfFillExternalBuffer(mask,                                                                                            \
2417                                                                                                                                    \
2418                                   ZCL_CLEAR_HOLIDAY_SCHEDULE_COMMAND_ID, "uu", scheduleId, status);
2419
2420 /** @brief Command description for SetUserType
2421  *
2422  * Command: SetUserType
2423  * @param userId INT16U
2424  * @param status INT8U
2425  * @param userType DoorLockUserType
2426  */
2427 #define emberAfFillCommandDoor                                                                                                     \
2428     LockClusterSetUserType(userId, status, userType)                                                                               \
2429         emberAfFillExternalBuffer(mask,                                                                                            \
2430                                                                                                                                    \
2431                                   ZCL_SET_USER_TYPE_COMMAND_ID, "uuu", userId, status, userType);
2432
2433 /** @brief Command description for GetUserType
2434  *
2435  * Command: GetUserType
2436  * @param userId INT16U
2437  * @param userId INT16U
2438  * @param userType DoorLockUserType
2439  */
2440 #define emberAfFillCommandDoor                                                                                                     \
2441     LockClusterGetUserType(userId, userId, userType)                                                                               \
2442         emberAfFillExternalBuffer(mask,                                                                                            \
2443                                                                                                                                    \
2444                                   ZCL_GET_USER_TYPE_COMMAND_ID, "uuu", userId, userId, userType);
2445
2446 /** @brief Command description for SetRfid
2447  *
2448  * Command: SetRfid
2449  * @param userId INT16U
2450  * @param status DoorLockSetPinOrIdStatus
2451  * @param userStatus DoorLockUserStatus
2452  * @param userType DoorLockUserType
2453  * @param id CHAR_STRING
2454  */
2455 #define emberAfFillCommandDoor                                                                                                     \
2456     LockClusterSetRfid(userId, status, userStatus, userType, id)                                                                   \
2457         emberAfFillExternalBuffer(mask,                                                                                            \
2458                                                                                                                                    \
2459                                   ZCL_SET_RFID_COMMAND_ID, "uuuuu", userId, status, userStatus, userType, id);
2460
2461 /** @brief Command description for GetRfid
2462  *
2463  * Command: GetRfid
2464  * @param userId INT16U
2465  * @param userId INT16U
2466  * @param userStatus DoorLockUserStatus
2467  * @param userType DoorLockUserType
2468  * @param rfid CHAR_STRING
2469  */
2470 #define emberAfFillCommandDoor                                                                                                     \
2471     LockClusterGetRfid(userId, userId, userStatus, userType, rfid)                                                                 \
2472         emberAfFillExternalBuffer(mask,                                                                                            \
2473                                                                                                                                    \
2474                                   ZCL_GET_RFID_COMMAND_ID, "uuuuu", userId, userId, userStatus, userType, rfid);
2475
2476 /** @brief Command description for ClearRfid
2477  *
2478  * Command: ClearRfid
2479  * @param userId INT16U
2480  * @param status INT8U
2481  */
2482 #define emberAfFillCommandDoor                                                                                                     \
2483     LockClusterClearRfid(userId, status) emberAfFillExternalBuffer(mask,                                                           \
2484                                                                                                                                    \
2485                                                                    ZCL_CLEAR_RFID_COMMAND_ID, "uu", userId, status);
2486
2487 /** @brief Command description for ClearAllRfids
2488  *
2489  * Command: ClearAllRfids
2490  * @param status INT8U
2491  */
2492 #define emberAfFillCommandDoor                                                                                                     \
2493     LockClusterClearAllRfids(status) emberAfFillExternalBuffer(mask,                                                               \
2494                                                                                                                                    \
2495                                                                ZCL_CLEAR_ALL_RFIDS_COMMAND_ID, "u", status);
2496
2497 /** @brief Command description for OperationEventNotification
2498  *
2499  * Command: OperationEventNotification
2500  * @param source INT8U
2501  * @param eventCode DoorLockOperationEventCode
2502  * @param userId INT16U
2503  * @param pin CHAR_STRING
2504  * @param timeStamp INT32U
2505  * @param data CHAR_STRING
2506  */
2507 #define emberAfFillCommandDoor                                                                                                     \
2508     LockClusterOperationEventNotification(source, eventCode, userId, pin, timeStamp, data) emberAfFillExternalBuffer(              \
2509         mask,                                                                                                                      \
2510                                                                                                                                    \
2511         ZCL_OPERATION_EVENT_NOTIFICATION_COMMAND_ID, "uuuuuu", source, eventCode, userId, pin, timeStamp, data);
2512
2513 /** @brief Command description for ProgrammingEventNotification
2514  *
2515  * Command: ProgrammingEventNotification
2516  * @param source INT8U
2517  * @param eventCode DoorLockProgrammingEventCode
2518  * @param userId INT16U
2519  * @param pin CHAR_STRING
2520  * @param userType DoorLockUserType
2521  * @param userStatus DoorLockUserStatus
2522  * @param timeStamp INT32U
2523  * @param data CHAR_STRING
2524  */
2525 #define emberAfFillCommandDoor                                                                                                     \
2526     LockClusterProgrammingEventNotification(source, eventCode, userId, pin, userType, userStatus, timeStamp, data)                 \
2527         emberAfFillExternalBuffer(mask,                                                                                            \
2528                                                                                                                                    \
2529                                   ZCL_PROGRAMMING_EVENT_NOTIFICATION_COMMAND_ID, "uuuuuuuu", source, eventCode, userId, pin,       \
2530                                   userType, userStatus, timeStamp, data);
2531
2532 /** @brief Command description for WindowCoveringUpOpen
2533  *
2534  * Command: WindowCoveringUpOpen
2535  */
2536 #define emberAfFillCommandWindow                                                                                                   \
2537     CoveringClusterWindowCoveringUpOpen() emberAfFillExternalBuffer(mask,                                                          \
2538                                                                                                                                    \
2539                                                                     ZCL_WINDOW_COVERING_UP_OPEN_COMMAND_ID, "", );
2540
2541 /** @brief Command description for WindowCoveringDownClose
2542  *
2543  * Command: WindowCoveringDownClose
2544  */
2545 #define emberAfFillCommandWindow                                                                                                   \
2546     CoveringClusterWindowCoveringDownClose() emberAfFillExternalBuffer(mask,                                                       \
2547                                                                                                                                    \
2548                                                                        ZCL_WINDOW_COVERING_DOWN_CLOSE_COMMAND_ID, "", );
2549
2550 /** @brief Command description for WindowCoveringStop
2551  *
2552  * Command: WindowCoveringStop
2553  */
2554 #define emberAfFillCommandWindow                                                                                                   \
2555     CoveringClusterWindowCoveringStop() emberAfFillExternalBuffer(mask,                                                            \
2556                                                                                                                                    \
2557                                                                   ZCL_WINDOW_COVERING_STOP_COMMAND_ID, "", );
2558
2559 /** @brief Command description for WindowCoveringGoToLiftValue
2560  *
2561  * Command: WindowCoveringGoToLiftValue
2562  * @param liftValue INT16U
2563  */
2564 #define emberAfFillCommandWindow                                                                                                   \
2565     CoveringClusterWindowCoveringGoToLiftValue(liftValue)                                                                          \
2566         emberAfFillExternalBuffer(mask,                                                                                            \
2567                                                                                                                                    \
2568                                   ZCL_WINDOW_COVERING_GO_TO_LIFT_VALUE_COMMAND_ID, "u", liftValue);
2569
2570 /** @brief Command description for WindowCoveringGoToLiftPercentage
2571  *
2572  * Command: WindowCoveringGoToLiftPercentage
2573  * @param percentageLiftValue INT8U
2574  */
2575 #define emberAfFillCommandWindow                                                                                                   \
2576     CoveringClusterWindowCoveringGoToLiftPercentage(percentageLiftValue)                                                           \
2577         emberAfFillExternalBuffer(mask,                                                                                            \
2578                                                                                                                                    \
2579                                   ZCL_WINDOW_COVERING_GO_TO_LIFT_PERCENTAGE_COMMAND_ID, "u", percentageLiftValue);
2580
2581 /** @brief Command description for WindowCoveringGoToTiltValue
2582  *
2583  * Command: WindowCoveringGoToTiltValue
2584  * @param tiltValue INT16U
2585  */
2586 #define emberAfFillCommandWindow                                                                                                   \
2587     CoveringClusterWindowCoveringGoToTiltValue(tiltValue)                                                                          \
2588         emberAfFillExternalBuffer(mask,                                                                                            \
2589                                                                                                                                    \
2590                                   ZCL_WINDOW_COVERING_GO_TO_TILT_VALUE_COMMAND_ID, "u", tiltValue);
2591
2592 /** @brief Command description for WindowCoveringGoToTiltPercentage
2593  *
2594  * Command: WindowCoveringGoToTiltPercentage
2595  * @param percentageTiltValue INT8U
2596  */
2597 #define emberAfFillCommandWindow                                                                                                   \
2598     CoveringClusterWindowCoveringGoToTiltPercentage(percentageTiltValue)                                                           \
2599         emberAfFillExternalBuffer(mask,                                                                                            \
2600                                                                                                                                    \
2601                                   ZCL_WINDOW_COVERING_GO_TO_TILT_PERCENTAGE_COMMAND_ID, "u", percentageTiltValue);
2602
2603 /** @brief Command description for BarrierControlGoToPercent
2604  *
2605  * Command: BarrierControlGoToPercent
2606  * @param percentOpen INT8U
2607  */
2608 #define emberAfFillCommandBarrier                                                                                                  \
2609     ControlClusterBarrierControlGoToPercent(percentOpen)                                                                           \
2610         emberAfFillExternalBuffer(mask,                                                                                            \
2611                                                                                                                                    \
2612                                   ZCL_BARRIER_CONTROL_GO_TO_PERCENT_COMMAND_ID, "u", percentOpen);
2613
2614 /** @brief Command description for BarrierControlStop
2615  *
2616  * Command: BarrierControlStop
2617  */
2618 #define emberAfFillCommandBarrier                                                                                                  \
2619     ControlClusterBarrierControlStop() emberAfFillExternalBuffer(mask,                                                             \
2620                                                                                                                                    \
2621                                                                  ZCL_BARRIER_CONTROL_STOP_COMMAND_ID, "", );
2622
2623 /** @brief Command description for SetpointRaiseLower
2624  *
2625  * Command: SetpointRaiseLower
2626  * @param mode SetpointAdjustMode
2627  * @param numberOfTransitionsForSequence ENUM8
2628  * @param amount INT8S
2629  * @param dayOfWeekForSequence DayOfWeek
2630  * @param modeForSequence ModeForSequence
2631  * @param payload INT8U []
2632  * @param payloadLen int
2633  */
2634 #define emberAfFillCommandThermostatClusterSetpointRaiseLower(mode, numberOfTransitionsForSequence, amount, dayOfWeekForSequence,  \
2635                                                               modeForSequence, payload, payloadLen)                                \
2636     emberAfFillExternalBuffer(mask,                                                                                                \
2637                                                                                                                                    \
2638                               ZCL_SETPOINT_RAISE_LOWER_COMMAND_ID, "uuuuub", mode, numberOfTransitionsForSequence, amount,         \
2639                               dayOfWeekForSequence, modeForSequence, payload, payloadLen);
2640
2641 /** @brief Command description for SetWeeklySchedule
2642  *
2643  * Command: SetWeeklySchedule
2644  * @param numberOfTransitionsForSequence ENUM8
2645  * @param timeOfDay INT16U
2646  * @param dayOfWeekForSequence DayOfWeek
2647  * @param relayStatus BITMAP16
2648  * @param modeForSequence ModeForSequence
2649  * @param localTemperature INT16S
2650  * @param payload INT8U []
2651  * @param payloadLen int
2652  * @param humidityInPercentage INT8U
2653  * @param setpoint INT16S
2654  * @param unreadEntries INT16U
2655  */
2656 #define emberAfFillCommandThermostatClusterSetWeeklySchedule(numberOfTransitionsForSequence, timeOfDay, dayOfWeekForSequence,      \
2657                                                              relayStatus, modeForSequence, localTemperature, payload, payloadLen,  \
2658                                                              humidityInPercentage, setpoint, unreadEntries)                        \
2659     emberAfFillExternalBuffer(mask,                                                                                                \
2660                                                                                                                                    \
2661                               ZCL_SET_WEEKLY_SCHEDULE_COMMAND_ID, "uuuuuubuuu", numberOfTransitionsForSequence, timeOfDay,         \
2662                               dayOfWeekForSequence, relayStatus, modeForSequence, localTemperature, payload, payloadLen,           \
2663                               humidityInPercentage, setpoint, unreadEntries);
2664
2665 /** @brief Command description for GetWeeklySchedule
2666  *
2667  * Command: GetWeeklySchedule
2668  * @param daysToReturn DayOfWeek
2669  * @param modeToReturn ModeForSequence
2670  */
2671 #define emberAfFillCommandThermostatClusterGetWeeklySchedule(daysToReturn, modeToReturn)                                           \
2672     emberAfFillExternalBuffer(mask,                                                                                                \
2673                                                                                                                                    \
2674                               ZCL_GET_WEEKLY_SCHEDULE_COMMAND_ID, "uu", daysToReturn, modeToReturn);
2675
2676 /** @brief Command description for ClearWeeklySchedule
2677  *
2678  * Command: ClearWeeklySchedule
2679  */
2680 #define emberAfFillCommandThermostatClusterClearWeeklySchedule()                                                                   \
2681     emberAfFillExternalBuffer(mask,                                                                                                \
2682                                                                                                                                    \
2683                               ZCL_CLEAR_WEEKLY_SCHEDULE_COMMAND_ID, "", );
2684
2685 /** @brief Command description for GetRelayStatusLog
2686  *
2687  * Command: GetRelayStatusLog
2688  */
2689 #define emberAfFillCommandThermostatClusterGetRelayStatusLog()                                                                     \
2690     emberAfFillExternalBuffer(mask,                                                                                                \
2691                                                                                                                                    \
2692                               ZCL_GET_RELAY_STATUS_LOG_COMMAND_ID, "", );
2693
2694 /** @brief Command description for MoveToHue
2695  *
2696  * Command: MoveToHue
2697  * @param hue INT8U
2698  * @param direction HueDirection
2699  * @param transitionTime INT16U
2700  * @param optionsMask BITMAP8
2701  * @param optionsOverride BITMAP8
2702  */
2703 #define emberAfFillCommandColor                                                                                                    \
2704     ControlClusterMoveToHue(hue, direction, transitionTime, optionsMask, optionsOverride) emberAfFillExternalBuffer(               \
2705         mask,                                                                                                                      \
2706                                                                                                                                    \
2707         ZCL_MOVE_TO_HUE_COMMAND_ID, "uuuuu", hue, direction, transitionTime, optionsMask, optionsOverride);
2708
2709 /** @brief Command description for MoveHue
2710  *
2711  * Command: MoveHue
2712  * @param moveMode HueMoveMode
2713  * @param rate INT8U
2714  * @param optionsMask BITMAP8
2715  * @param optionsOverride BITMAP8
2716  */
2717 #define emberAfFillCommandColor                                                                                                    \
2718     ControlClusterMoveHue(moveMode, rate, optionsMask, optionsOverride)                                                            \
2719         emberAfFillExternalBuffer(mask,                                                                                            \
2720                                                                                                                                    \
2721                                   ZCL_MOVE_HUE_COMMAND_ID, "uuuu", moveMode, rate, optionsMask, optionsOverride);
2722
2723 /** @brief Command description for StepHue
2724  *
2725  * Command: StepHue
2726  * @param stepMode HueStepMode
2727  * @param stepSize INT8U
2728  * @param transitionTime INT8U
2729  * @param optionsMask BITMAP8
2730  * @param optionsOverride BITMAP8
2731  */
2732 #define emberAfFillCommandColor                                                                                                    \
2733     ControlClusterStepHue(stepMode, stepSize, transitionTime, optionsMask, optionsOverride) emberAfFillExternalBuffer(             \
2734         mask,                                                                                                                      \
2735                                                                                                                                    \
2736         ZCL_STEP_HUE_COMMAND_ID, "uuuuu", stepMode, stepSize, transitionTime, optionsMask, optionsOverride);
2737
2738 /** @brief Command description for MoveToSaturation
2739  *
2740  * Command: MoveToSaturation
2741  * @param saturation INT8U
2742  * @param transitionTime INT16U
2743  * @param optionsMask BITMAP8
2744  * @param optionsOverride BITMAP8
2745  */
2746 #define emberAfFillCommandColor                                                                                                    \
2747     ControlClusterMoveToSaturation(saturation, transitionTime, optionsMask, optionsOverride) emberAfFillExternalBuffer(            \
2748         mask,                                                                                                                      \
2749                                                                                                                                    \
2750         ZCL_MOVE_TO_SATURATION_COMMAND_ID, "uuuu", saturation, transitionTime, optionsMask, optionsOverride);
2751
2752 /** @brief Command description for MoveSaturation
2753  *
2754  * Command: MoveSaturation
2755  * @param moveMode SaturationMoveMode
2756  * @param rate INT8U
2757  * @param optionsMask BITMAP8
2758  * @param optionsOverride BITMAP8
2759  */
2760 #define emberAfFillCommandColor                                                                                                    \
2761     ControlClusterMoveSaturation(moveMode, rate, optionsMask, optionsOverride)                                                     \
2762         emberAfFillExternalBuffer(mask,                                                                                            \
2763                                                                                                                                    \
2764                                   ZCL_MOVE_SATURATION_COMMAND_ID, "uuuu", moveMode, rate, optionsMask, optionsOverride);
2765
2766 /** @brief Command description for StepSaturation
2767  *
2768  * Command: StepSaturation
2769  * @param stepMode SaturationStepMode
2770  * @param stepSize INT8U
2771  * @param transitionTime INT8U
2772  * @param optionsMask BITMAP8
2773  * @param optionsOverride BITMAP8
2774  */
2775 #define emberAfFillCommandColor                                                                                                    \
2776     ControlClusterStepSaturation(stepMode, stepSize, transitionTime, optionsMask, optionsOverride) emberAfFillExternalBuffer(      \
2777         mask,                                                                                                                      \
2778                                                                                                                                    \
2779         ZCL_STEP_SATURATION_COMMAND_ID, "uuuuu", stepMode, stepSize, transitionTime, optionsMask, optionsOverride);
2780
2781 /** @brief Command description for MoveToHueAndSaturation
2782  *
2783  * Command: MoveToHueAndSaturation
2784  * @param hue INT8U
2785  * @param saturation INT8U
2786  * @param transitionTime INT16U
2787  * @param optionsMask BITMAP8
2788  * @param optionsOverride BITMAP8
2789  */
2790 #define emberAfFillCommandColor                                                                                                    \
2791     ControlClusterMoveToHueAndSaturation(hue, saturation, transitionTime, optionsMask, optionsOverride) emberAfFillExternalBuffer( \
2792         mask,                                                                                                                      \
2793                                                                                                                                    \
2794         ZCL_MOVE_TO_HUE_AND_SATURATION_COMMAND_ID, "uuuuu", hue, saturation, transitionTime, optionsMask, optionsOverride);
2795
2796 /** @brief Command description for MoveToColor
2797  *
2798  * Command: MoveToColor
2799  * @param colorX INT16U
2800  * @param colorY INT16U
2801  * @param transitionTime INT16U
2802  * @param optionsMask BITMAP8
2803  * @param optionsOverride BITMAP8
2804  */
2805 #define emberAfFillCommandColor                                                                                                    \
2806     ControlClusterMoveToColor(colorX, colorY, transitionTime, optionsMask, optionsOverride) emberAfFillExternalBuffer(             \
2807         mask,                                                                                                                      \
2808                                                                                                                                    \
2809         ZCL_MOVE_TO_COLOR_COMMAND_ID, "uuuuu", colorX, colorY, transitionTime, optionsMask, optionsOverride);
2810
2811 /** @brief Command description for MoveColor
2812  *
2813  * Command: MoveColor
2814  * @param rateX INT16S
2815  * @param rateY INT16S
2816  * @param optionsMask BITMAP8
2817  * @param optionsOverride BITMAP8
2818  */
2819 #define emberAfFillCommandColor                                                                                                    \
2820     ControlClusterMoveColor(rateX, rateY, optionsMask, optionsOverride)                                                            \
2821         emberAfFillExternalBuffer(mask,                                                                                            \
2822                                                                                                                                    \
2823                                   ZCL_MOVE_COLOR_COMMAND_ID, "uuuu", rateX, rateY, optionsMask, optionsOverride);
2824
2825 /** @brief Command description for StepColor
2826  *
2827  * Command: StepColor
2828  * @param stepX INT16S
2829  * @param stepY INT16S
2830  * @param transitionTime INT16U
2831  * @param optionsMask BITMAP8
2832  * @param optionsOverride BITMAP8
2833  */
2834 #define emberAfFillCommandColor                                                                                                    \
2835     ControlClusterStepColor(stepX, stepY, transitionTime, optionsMask, optionsOverride)                                            \
2836         emberAfFillExternalBuffer(mask,                                                                                            \
2837                                                                                                                                    \
2838                                   ZCL_STEP_COLOR_COMMAND_ID, "uuuuu", stepX, stepY, transitionTime, optionsMask, optionsOverride);
2839
2840 /** @brief Command description for MoveToColorTemperature
2841  *
2842  * Command: MoveToColorTemperature
2843  * @param colorTemperature INT16U
2844  * @param transitionTime INT16U
2845  * @param optionsMask BITMAP8
2846  * @param optionsOverride BITMAP8
2847  */
2848 #define emberAfFillCommandColor                                                                                                    \
2849     ControlClusterMoveToColorTemperature(colorTemperature, transitionTime, optionsMask, optionsOverride)                           \
2850         emberAfFillExternalBuffer(mask,                                                                                            \
2851                                                                                                                                    \
2852                                   ZCL_MOVE_TO_COLOR_TEMPERATURE_COMMAND_ID, "uuuu", colorTemperature, transitionTime, optionsMask, \
2853                                   optionsOverride);
2854
2855 /** @brief Command description for EnhancedMoveToHue
2856  *
2857  * Command: EnhancedMoveToHue
2858  * @param enhancedHue INT16U
2859  * @param direction HueDirection
2860  * @param transitionTime INT16U
2861  */
2862 #define emberAfFillCommandColor                                                                                                    \
2863     ControlClusterEnhancedMoveToHue(enhancedHue, direction, transitionTime)                                                        \
2864         emberAfFillExternalBuffer(mask,                                                                                            \
2865                                                                                                                                    \
2866                                   ZCL_ENHANCED_MOVE_TO_HUE_COMMAND_ID, "uuu", enhancedHue, direction, transitionTime);
2867
2868 /** @brief Command description for EnhancedMoveHue
2869  *
2870  * Command: EnhancedMoveHue
2871  * @param moveMode HueMoveMode
2872  * @param rate INT16U
2873  */
2874 #define emberAfFillCommandColor                                                                                                    \
2875     ControlClusterEnhancedMoveHue(moveMode, rate)                                                                                  \
2876         emberAfFillExternalBuffer(mask,                                                                                            \
2877                                                                                                                                    \
2878                                   ZCL_ENHANCED_MOVE_HUE_COMMAND_ID, "uu", moveMode, rate);
2879
2880 /** @brief Command description for EnhancedStepHue
2881  *
2882  * Command: EnhancedStepHue
2883  * @param stepMode HueStepMode
2884  * @param stepSize INT16U
2885  * @param transitionTime INT16U
2886  */
2887 #define emberAfFillCommandColor                                                                                                    \
2888     ControlClusterEnhancedStepHue(stepMode, stepSize, transitionTime)                                                              \
2889         emberAfFillExternalBuffer(mask,                                                                                            \
2890                                                                                                                                    \
2891                                   ZCL_ENHANCED_STEP_HUE_COMMAND_ID, "uuu", stepMode, stepSize, transitionTime);
2892
2893 /** @brief Command description for EnhancedMoveToHueAndSaturation
2894  *
2895  * Command: EnhancedMoveToHueAndSaturation
2896  * @param enhancedHue INT16U
2897  * @param saturation INT8U
2898  * @param transitionTime INT16U
2899  */
2900 #define emberAfFillCommandColor                                                                                                    \
2901     ControlClusterEnhancedMoveToHueAndSaturation(enhancedHue, saturation, transitionTime) emberAfFillExternalBuffer(               \
2902         mask,                                                                                                                      \
2903                                                                                                                                    \
2904         ZCL_ENHANCED_MOVE_TO_HUE_AND_SATURATION_COMMAND_ID, "uuu", enhancedHue, saturation, transitionTime);
2905
2906 /** @brief Command description for ColorLoopSet
2907  *
2908  * Command: ColorLoopSet
2909  * @param updateFlags ColorLoopUpdateFlags
2910  * @param action ColorLoopAction
2911  * @param direction ColorLoopDirection
2912  * @param time INT16U
2913  * @param startHue INT16U
2914  */
2915 #define emberAfFillCommandColor                                                                                                    \
2916     ControlClusterColorLoopSet(updateFlags, action, direction, time, startHue)                                                     \
2917         emberAfFillExternalBuffer(mask,                                                                                            \
2918                                                                                                                                    \
2919                                   ZCL_COLOR_LOOP_SET_COMMAND_ID, "uuuuu", updateFlags, action, direction, time, startHue);
2920
2921 /** @brief Command description for StopMoveStep
2922  *
2923  * Command: StopMoveStep
2924  * @param optionsMask BITMAP8
2925  * @param optionsOverride BITMAP8
2926  */
2927 #define emberAfFillCommandColor                                                                                                    \
2928     ControlClusterStopMoveStep(optionsMask, optionsOverride)                                                                       \
2929         emberAfFillExternalBuffer(mask,                                                                                            \
2930                                                                                                                                    \
2931                                   ZCL_STOP_MOVE_STEP_COMMAND_ID, "uu", optionsMask, optionsOverride);
2932
2933 /** @brief Command description for MoveColorTemperature
2934  *
2935  * Command: MoveColorTemperature
2936  * @param moveMode HueMoveMode
2937  * @param rate INT16U
2938  * @param colorTemperatureMinimum INT16U
2939  * @param colorTemperatureMaximum INT16U
2940  * @param optionsMask BITMAP8
2941  * @param optionsOverride BITMAP8
2942  */
2943 #define emberAfFillCommandColor                                                                                                    \
2944     ControlClusterMoveColorTemperature(moveMode, rate, colorTemperatureMinimum, colorTemperatureMaximum, optionsMask,              \
2945                                        optionsOverride)                                                                            \
2946         emberAfFillExternalBuffer(mask,                                                                                            \
2947                                                                                                                                    \
2948                                   ZCL_MOVE_COLOR_TEMPERATURE_COMMAND_ID, "uuuuuu", moveMode, rate, colorTemperatureMinimum,        \
2949                                   colorTemperatureMaximum, optionsMask, optionsOverride);
2950
2951 /** @brief Command description for StepColorTemperature
2952  *
2953  * Command: StepColorTemperature
2954  * @param stepMode HueStepMode
2955  * @param stepSize INT16U
2956  * @param transitionTime INT16U
2957  * @param colorTemperatureMinimum INT16U
2958  * @param colorTemperatureMaximum INT16U
2959  * @param optionsMask BITMAP8
2960  * @param optionsOverride BITMAP8
2961  */
2962 #define emberAfFillCommandColor                                                                                                    \
2963     ControlClusterStepColorTemperature(stepMode, stepSize, transitionTime, colorTemperatureMinimum, colorTemperatureMaximum,       \
2964                                        optionsMask, optionsOverride)                                                               \
2965         emberAfFillExternalBuffer(mask,                                                                                            \
2966                                                                                                                                    \
2967                                   ZCL_STEP_COLOR_TEMPERATURE_COMMAND_ID, "uuuuuuu", stepMode, stepSize, transitionTime,            \
2968                                   colorTemperatureMinimum, colorTemperatureMaximum, optionsMask, optionsOverride);
2969
2970 /** @brief Command description for ZoneEnrollResponse
2971  *
2972  * Command: ZoneEnrollResponse
2973  * @param enrollResponseCode IasEnrollResponseCode
2974  * @param zoneStatus IasZoneStatus
2975  * @param zoneId INT8U
2976  * @param extendedStatus BITMAP8
2977  * @param zoneId INT8U
2978  * @param delay INT16U
2979  */
2980 #define emberAfFillCommandIAS                                                                                                      \
2981     ZoneClusterZoneEnrollResponse(enrollResponseCode, zoneStatus, zoneId, extendedStatus, zoneId, delay)                           \
2982         emberAfFillExternalBuffer(mask,                                                                                            \
2983                                                                                                                                    \
2984                                   ZCL_ZONE_ENROLL_RESPONSE_COMMAND_ID, "uuuuuu", enrollResponseCode, zoneStatus, zoneId,           \
2985                                   extendedStatus, zoneId, delay);
2986
2987 /** @brief Command description for InitiateNormalOperationMode
2988  *
2989  * Command: InitiateNormalOperationMode
2990  * @param zoneType IasZoneType
2991  * @param manufacturerCode INT16U
2992  */
2993 #define emberAfFillCommandIAS                                                                                                      \
2994     ZoneClusterInitiateNormalOperationMode(zoneType, manufacturerCode)                                                             \
2995         emberAfFillExternalBuffer(mask,                                                                                            \
2996                                                                                                                                    \
2997                                   ZCL_INITIATE_NORMAL_OPERATION_MODE_COMMAND_ID, "uu", zoneType, manufacturerCode);
2998
2999 /** @brief Command description for InitiateNormalOperationModeResponse
3000  *
3001  * Command: InitiateNormalOperationModeResponse
3002  * @param testModeDuration INT8U
3003  * @param currentZoneSensitivityLevel INT8U
3004  */
3005 #define emberAfFillCommandIAS                                                                                                      \
3006     ZoneClusterInitiateNormalOperationModeResponse(testModeDuration, currentZoneSensitivityLevel) emberAfFillExternalBuffer(       \
3007         mask,                                                                                                                      \
3008                                                                                                                                    \
3009         ZCL_INITIATE_NORMAL_OPERATION_MODE_RESPONSE_COMMAND_ID, "uu", testModeDuration, currentZoneSensitivityLevel);
3010
3011 /** @brief Command description for InitiateTestModeResponse
3012  *
3013  * Command: InitiateTestModeResponse
3014  */
3015 #define emberAfFillCommandIAS                                                                                                      \
3016     ZoneClusterInitiateTestModeResponse() emberAfFillExternalBuffer(mask,                                                          \
3017                                                                                                                                    \
3018                                                                     ZCL_INITIATE_TEST_MODE_RESPONSE_COMMAND_ID, "", );
3019
3020 /** @brief Command description for Arm
3021  *
3022  * Command: Arm
3023  * @param armMode IasAceArmMode
3024  * @param armNotification IasAceArmNotification
3025  * @param armDisarmCode CHAR_STRING
3026  * @param zoneId INT8U
3027  */
3028 #define emberAfFillCommandIAS                                                                                                      \
3029     ACEClusterArm(armMode, armNotification, armDisarmCode, zoneId)                                                                 \
3030         emberAfFillExternalBuffer(mask,                                                                                            \
3031                                                                                                                                    \
3032                                   ZCL_ARM_COMMAND_ID, "uuuu", armMode, armNotification, armDisarmCode, zoneId);
3033
3034 /** @brief Command description for Bypass
3035  *
3036  * Command: Bypass
3037  * @param numberOfZones INT8U
3038  * @param section0 BITMAP16
3039  * @param zoneIds INT8U []
3040  * @param zoneIdsLen int
3041  * @param section1 BITMAP16
3042  * @param armDisarmCode CHAR_STRING
3043  * @param section2 BITMAP16
3044  * @param section3 BITMAP16
3045  * @param section4 BITMAP16
3046  * @param section5 BITMAP16
3047  * @param section6 BITMAP16
3048  * @param section7 BITMAP16
3049  * @param section8 BITMAP16
3050  * @param section9 BITMAP16
3051  * @param section10 BITMAP16
3052  * @param section11 BITMAP16
3053  * @param section12 BITMAP16
3054  * @param section13 BITMAP16
3055  * @param section14 BITMAP16
3056  * @param section15 BITMAP16
3057  */
3058 #define emberAfFillCommandIAS                                                                                                      \
3059     ACEClusterBypass(numberOfZones, section0, zoneIds, zoneIdsLen, section1, armDisarmCode, section2, section3, section4,          \
3060                      section5, section6, section7, section8, section9, section10, section11, section12, section13, section14,      \
3061                      section15)                                                                                                    \
3062         emberAfFillExternalBuffer(mask,                                                                                            \
3063                                                                                                                                    \
3064                                   ZCL_BYPASS_COMMAND_ID, "uubuuuuuuuuuuuuuuuu", numberOfZones, section0, zoneIds, zoneIdsLen,      \
3065                                   section1, armDisarmCode, section2, section3, section4, section5, section6, section7, section8,   \
3066                                   section9, section10, section11, section12, section13, section14, section15);
3067
3068 /** @brief Command description for Emergency
3069  *
3070  * Command: Emergency
3071  * @param zoneId INT8U
3072  * @param zoneType IasZoneType
3073  * @param ieeeAddress IEEE_ADDRESS
3074  * @param zoneLabel CHAR_STRING
3075  */
3076 #define emberAfFillCommandIAS                                                                                                      \
3077     ACEClusterEmergency(zoneId, zoneType, ieeeAddress, zoneLabel)                                                                  \
3078         emberAfFillExternalBuffer(mask,                                                                                            \
3079                                                                                                                                    \
3080                                   ZCL_EMERGENCY_COMMAND_ID, "uuuu", zoneId, zoneType, ieeeAddress, zoneLabel);
3081
3082 /** @brief Command description for Fire
3083  *
3084  * Command: Fire
3085  * @param zoneId INT8U
3086  * @param zoneStatus ENUM16
3087  * @param audibleNotification IasAceAudibleNotification
3088  * @param zoneLabel CHAR_STRING
3089  */
3090 #define emberAfFillCommandIAS                                                                                                      \
3091     ACEClusterFire(zoneId, zoneStatus, audibleNotification, zoneLabel)                                                             \
3092         emberAfFillExternalBuffer(mask,                                                                                            \
3093                                                                                                                                    \
3094                                   ZCL_FIRE_COMMAND_ID, "uuuu", zoneId, zoneStatus, audibleNotification, zoneLabel);
3095
3096 /** @brief Command description for Panic
3097  *
3098  * Command: Panic
3099  * @param panelStatus IasAcePanelStatus
3100  * @param secondsRemaining INT8U
3101  * @param audibleNotification IasAceAudibleNotification
3102  * @param alarmStatus IasAceAlarmStatus
3103  */
3104 #define emberAfFillCommandIAS                                                                                                      \
3105     ACEClusterPanic(panelStatus, secondsRemaining, audibleNotification, alarmStatus)                                               \
3106         emberAfFillExternalBuffer(mask,                                                                                            \
3107                                                                                                                                    \
3108                                   ZCL_PANIC_COMMAND_ID, "uuuu", panelStatus, secondsRemaining, audibleNotification, alarmStatus);
3109
3110 /** @brief Command description for GetZoneIdMap
3111  *
3112  * Command: GetZoneIdMap
3113  * @param panelStatus IasAcePanelStatus
3114  * @param secondsRemaining INT8U
3115  * @param audibleNotification IasAceAudibleNotification
3116  * @param alarmStatus IasAceAlarmStatus
3117  */
3118 #define emberAfFillCommandIAS                                                                                                      \
3119     ACEClusterGetZoneIdMap(panelStatus, secondsRemaining, audibleNotification, alarmStatus) emberAfFillExternalBuffer(             \
3120         mask,                                                                                                                      \
3121                                                                                                                                    \
3122         ZCL_GET_ZONE_ID_MAP_COMMAND_ID, "uuuu", panelStatus, secondsRemaining, audibleNotification, alarmStatus);
3123
3124 /** @brief Command description for GetZoneInformation
3125  *
3126  * Command: GetZoneInformation
3127  * @param zoneId INT8U
3128  * @param numberOfZones INT8U
3129  * @param zoneIds INT8U []
3130  * @param zoneIdsLen int
3131  */
3132 #define emberAfFillCommandIAS                                                                                                      \
3133     ACEClusterGetZoneInformation(zoneId, numberOfZones, zoneIds, zoneIdsLen)                                                       \
3134         emberAfFillExternalBuffer(mask,                                                                                            \
3135                                                                                                                                    \
3136                                   ZCL_GET_ZONE_INFORMATION_COMMAND_ID, "uub", zoneId, numberOfZones, zoneIds, zoneIdsLen);
3137
3138 /** @brief Command description for GetPanelStatus
3139  *
3140  * Command: GetPanelStatus
3141  * @param numberOfZones INT8U
3142  * @param bypassResult IasAceBypassResult []
3143  * @param bypassResultLen int
3144  */
3145 #define emberAfFillCommandIAS                                                                                                      \
3146     ACEClusterGetPanelStatus(numberOfZones, bypassResult, bypassResultLen)                                                         \
3147         emberAfFillExternalBuffer(mask,                                                                                            \
3148                                                                                                                                    \
3149                                   ZCL_GET_PANEL_STATUS_COMMAND_ID, "ub", numberOfZones, bypassResult, bypassResultLen);
3150
3151 /** @brief Command description for GetBypassedZoneList
3152  *
3153  * Command: GetBypassedZoneList
3154  * @param zoneStatusComplete BOOLEAN
3155  * @param numberOfZones INT8U
3156  * @param zoneStatusResult IasAceZoneStatusResult []
3157  * @param zoneStatusResultLen int
3158  */
3159 #define emberAfFillCommandIAS                                                                                                      \
3160     ACEClusterGetBypassedZoneList(zoneStatusComplete, numberOfZones, zoneStatusResult, zoneStatusResultLen)                        \
3161         emberAfFillExternalBuffer(mask,                                                                                            \
3162                                                                                                                                    \
3163                                   ZCL_GET_BYPASSED_ZONE_LIST_COMMAND_ID, "uub", zoneStatusComplete, numberOfZones,                 \
3164                                   zoneStatusResult, zoneStatusResultLen);
3165
3166 /** @brief Command description for GetZoneStatus
3167  *
3168  * Command: GetZoneStatus
3169  * @param startingZoneId INT8U
3170  * @param maxNumberOfZoneIds INT8U
3171  * @param zoneStatusMaskFlag BOOLEAN
3172  * @param zoneStatusMask BITMAP16
3173  */
3174 #define emberAfFillCommandIAS                                                                                                      \
3175     ACEClusterGetZoneStatus(startingZoneId, maxNumberOfZoneIds, zoneStatusMaskFlag, zoneStatusMask) emberAfFillExternalBuffer(     \
3176         mask,                                                                                                                      \
3177                                                                                                                                    \
3178         ZCL_GET_ZONE_STATUS_COMMAND_ID, "uuuu", startingZoneId, maxNumberOfZoneIds, zoneStatusMaskFlag, zoneStatusMask);
3179
3180 /** @brief Command description for StartWarning
3181  *
3182  * Command: StartWarning
3183  * @param warningInfo WarningInfo
3184  * @param warningDuration INT16U
3185  * @param strobeDutyCycle INT8U
3186  * @param strobeLevel ENUM8
3187  */
3188 #define emberAfFillCommandIAS                                                                                                      \
3189     WDClusterStartWarning(warningInfo, warningDuration, strobeDutyCycle, strobeLevel) emberAfFillExternalBuffer(                   \
3190         mask,                                                                                                                      \
3191                                                                                                                                    \
3192         ZCL_START_WARNING_COMMAND_ID, "uuuu", warningInfo, warningDuration, strobeDutyCycle, strobeLevel);
3193
3194 /** @brief Command description for Squawk
3195  *
3196  * Command: Squawk
3197  * @param squawkInfo SquawkInfo
3198  */
3199 #define emberAfFillCommandIAS                                                                                                      \
3200     WDClusterSquawk(squawkInfo) emberAfFillExternalBuffer(mask,                                                                    \
3201                                                                                                                                    \
3202                                                           ZCL_SQUAWK_COMMAND_ID, "u", squawkInfo);
3203
3204 /** @brief Command description for PlayRequest
3205  *
3206  * Command: PlayRequest
3207  */
3208 #define emberAfFillCommandMedia                                                                                                    \
3209     PlaybackClusterPlayRequest() emberAfFillExternalBuffer(mask,                                                                   \
3210                                                                                                                                    \
3211                                                            ZCL_PLAY_REQUEST_COMMAND_ID, "", );
3212
3213 /** @brief Command description for PauseRequest
3214  *
3215  * Command: PauseRequest
3216  */
3217 #define emberAfFillCommandMedia                                                                                                    \
3218     PlaybackClusterPauseRequest() emberAfFillExternalBuffer(mask,                                                                  \
3219                                                                                                                                    \
3220                                                             ZCL_PAUSE_REQUEST_COMMAND_ID, "", );
3221
3222 /** @brief Command description for StopRequest
3223  *
3224  * Command: StopRequest
3225  */
3226 #define emberAfFillCommandMedia                                                                                                    \
3227     PlaybackClusterStopRequest() emberAfFillExternalBuffer(mask,                                                                   \
3228                                                                                                                                    \
3229                                                            ZCL_STOP_REQUEST_COMMAND_ID, "", );
3230
3231 /** @brief Command description for StartOverRequest
3232  *
3233  * Command: StartOverRequest
3234  */
3235 #define emberAfFillCommandMedia                                                                                                    \
3236     PlaybackClusterStartOverRequest() emberAfFillExternalBuffer(mask,                                                              \
3237                                                                                                                                    \
3238                                                                 ZCL_START_OVER_REQUEST_COMMAND_ID, "", );
3239
3240 /** @brief Command description for PreviousRequest
3241  *
3242  * Command: PreviousRequest
3243  */
3244 #define emberAfFillCommandMedia                                                                                                    \
3245     PlaybackClusterPreviousRequest() emberAfFillExternalBuffer(mask,                                                               \
3246                                                                                                                                    \
3247                                                                ZCL_PREVIOUS_REQUEST_COMMAND_ID, "", );
3248
3249 /** @brief Command description for NextRequest
3250  *
3251  * Command: NextRequest
3252  */
3253 #define emberAfFillCommandMedia                                                                                                    \
3254     PlaybackClusterNextRequest() emberAfFillExternalBuffer(mask,                                                                   \
3255                                                                                                                                    \
3256                                                            ZCL_NEXT_REQUEST_COMMAND_ID, "", );
3257
3258 /** @brief Command description for RewindRequest
3259  *
3260  * Command: RewindRequest
3261  */
3262 #define emberAfFillCommandMedia                                                                                                    \
3263     PlaybackClusterRewindRequest() emberAfFillExternalBuffer(mask,                                                                 \
3264                                                                                                                                    \
3265                                                              ZCL_REWIND_REQUEST_COMMAND_ID, "", );
3266
3267 /** @brief Command description for FastForwardRequest
3268  *
3269  * Command: FastForwardRequest
3270  */
3271 #define emberAfFillCommandMedia                                                                                                    \
3272     PlaybackClusterFastForwardRequest() emberAfFillExternalBuffer(mask,                                                            \
3273                                                                                                                                    \
3274                                                                   ZCL_FAST_FORWARD_REQUEST_COMMAND_ID, "", );
3275
3276 /** @brief Command description for SkipForwardRequest
3277  *
3278  * Command: SkipForwardRequest
3279  */
3280 #define emberAfFillCommandMedia                                                                                                    \
3281     PlaybackClusterSkipForwardRequest() emberAfFillExternalBuffer(mask,                                                            \
3282                                                                                                                                    \
3283                                                                   ZCL_SKIP_FORWARD_REQUEST_COMMAND_ID, "", );
3284
3285 /** @brief Command description for SkipBackwardRequest
3286  *
3287  * Command: SkipBackwardRequest
3288  */
3289 #define emberAfFillCommandMedia                                                                                                    \
3290     PlaybackClusterSkipBackwardRequest() emberAfFillExternalBuffer(mask,                                                           \
3291                                                                                                                                    \
3292                                                                    ZCL_SKIP_BACKWARD_REQUEST_COMMAND_ID, "", );
3293
3294 /** @brief Command description for Sleep
3295  *
3296  * Command: Sleep
3297  */
3298 #define emberAfFillCommandLow                                                                                                      \
3299     PowerClusterSleep() emberAfFillExternalBuffer(mask,                                                                            \
3300                                                                                                                                    \
3301                                                   ZCL_SLEEP_COMMAND_ID, "", );
3302
3303 /** @brief Command description for LaunchContent
3304  *
3305  * Command: LaunchContent
3306  * @param contentLaunchStatus ContentLaunchStatus
3307  */
3308 #define emberAfFillCommandContent                                                                                                  \
3309     LaunchClusterLaunchContent(contentLaunchStatus)                                                                                \
3310         emberAfFillExternalBuffer(mask,                                                                                            \
3311                                                                                                                                    \
3312                                   ZCL_LAUNCH_CONTENT_COMMAND_ID, "u", contentLaunchStatus);
3313
3314 /** @brief Command description for LaunchURL
3315  *
3316  * Command: LaunchURL
3317  * @param contentLaunchStatus ContentLaunchStatus
3318  */
3319 #define emberAfFillCommandContent                                                                                                  \
3320     LaunchClusterLaunchURL(contentLaunchStatus) emberAfFillExternalBuffer(mask,                                                    \
3321                                                                                                                                    \
3322                                                                           ZCL_LAUNCH_URL_COMMAND_ID, "u", contentLaunchStatus);
3323
3324 /** @brief Command description for MatchProtocolAddress
3325  *
3326  * Command: MatchProtocolAddress
3327  * @param protocolAddress OCTET_STRING
3328  * @param deviceIeeeAddress IEEE_ADDRESS
3329  * @param protocolAddress OCTET_STRING
3330  */
3331 #define emberAfFillCommandGeneric                                                                                                  \
3332     TunnelClusterMatchProtocolAddress(protocolAddress, deviceIeeeAddress, protocolAddress) emberAfFillExternalBuffer(              \
3333         mask,                                                                                                                      \
3334                                                                                                                                    \
3335         ZCL_MATCH_PROTOCOL_ADDRESS_COMMAND_ID, "uuu", protocolAddress, deviceIeeeAddress, protocolAddress);
3336
3337 /** @brief Command description for AdvertiseProtocolAddress
3338  *
3339  * Command: AdvertiseProtocolAddress
3340  * @param protocolAddress OCTET_STRING
3341  */
3342 #define emberAfFillCommandGeneric                                                                                                  \
3343     TunnelClusterAdvertiseProtocolAddress(protocolAddress)                                                                         \
3344         emberAfFillExternalBuffer(mask,                                                                                            \
3345                                                                                                                                    \
3346                                   ZCL_ADVERTISE_PROTOCOL_ADDRESS_COMMAND_ID, "u", protocolAddress);
3347
3348 /** @brief Command description for TransferNpdu
3349  *
3350  * Command: TransferNpdu
3351  * @param npdu DATA8 []
3352  * @param npduLen int
3353  */
3354 #define emberAfFillCommandBACnet                                                                                                   \
3355     Protocol TunnelClusterTransferNpdu(npdu, npduLen) emberAfFillExternalBuffer(mask,                                              \
3356                                                                                                                                    \
3357                                                                                 ZCL_TRANSFER_NPDU_COMMAND_ID, "b", npdu, npduLen);
3358
3359 /** @brief Command description for TransferAPDU
3360  *
3361  * Command: TransferAPDU
3362  * @param apdu OCTET_STRING
3363  */
3364 #define emberAfFillCommand11073                                                                                                    \
3365     Protocol TunnelClusterTransferAPDU(apdu) emberAfFillExternalBuffer(mask,                                                       \
3366                                                                                                                                    \
3367                                                                        ZCL_TRANSFER_APDU_COMMAND_ID, "u", apdu);
3368
3369 /** @brief Command description for ConnectRequest
3370  *
3371  * Command: ConnectRequest
3372  * @param connectControl 11073ConnectRequestConnectControl
3373  * @param idleTimeout INT16U
3374  * @param managerTarget IEEE_ADDRESS
3375  * @param managerEndpoint INT8U
3376  */
3377 #define emberAfFillCommand11073                                                                                                    \
3378     Protocol TunnelClusterConnectRequest(connectControl, idleTimeout, managerTarget, managerEndpoint) emberAfFillExternalBuffer(   \
3379         mask,                                                                                                                      \
3380                                                                                                                                    \
3381         ZCL_CONNECT_REQUEST_COMMAND_ID, "uuuu", connectControl, idleTimeout, managerTarget, managerEndpoint);
3382
3383 /** @brief Command description for DisconnectRequest
3384  *
3385  * Command: DisconnectRequest
3386  * @param managerIEEEAddress IEEE_ADDRESS
3387  */
3388 #define emberAfFillCommand11073                                                                                                    \
3389     Protocol TunnelClusterDisconnectRequest(managerIEEEAddress)                                                                    \
3390         emberAfFillExternalBuffer(mask,                                                                                            \
3391                                                                                                                                    \
3392                                   ZCL_DISCONNECT_REQUEST_COMMAND_ID, "u", managerIEEEAddress);
3393
3394 /** @brief Command description for ConnectStatusNotification
3395  *
3396  * Command: ConnectStatusNotification
3397  * @param connectStatus 11073TunnelConnectionStatus
3398  */
3399 #define emberAfFillCommand11073                                                                                                    \
3400     Protocol TunnelClusterConnectStatusNotification(connectStatus)                                                                 \
3401         emberAfFillExternalBuffer(mask,                                                                                            \
3402                                                                                                                                    \
3403                                   ZCL_CONNECT_STATUS_NOTIFICATION_COMMAND_ID, "u", connectStatus);
3404
3405 /** @brief Command description for TransferApdu
3406  *
3407  * Command: TransferApdu
3408  * @param apdu OCTET_STRING
3409  */
3410 #define emberAfFillCommandISO                                                                                                      \
3411     7816 Protocol TunnelClusterTransferApdu(apdu) emberAfFillExternalBuffer(mask,                                                  \
3412                                                                                                                                    \
3413                                                                             ZCL_TRANSFER_APDU_COMMAND_ID, "u", apdu);
3414
3415 /** @brief Command description for InsertSmartCard
3416  *
3417  * Command: InsertSmartCard
3418  */
3419 #define emberAfFillCommandISO                                                                                                      \
3420     7816 Protocol TunnelClusterInsertSmartCard() emberAfFillExternalBuffer(mask,                                                   \
3421                                                                                                                                    \
3422                                                                            ZCL_INSERT_SMART_CARD_COMMAND_ID, "", );
3423
3424 /** @brief Command description for ExtractSmartCard
3425  *
3426  * Command: ExtractSmartCard
3427  */
3428 #define emberAfFillCommandISO                                                                                                      \
3429     7816 Protocol TunnelClusterExtractSmartCard() emberAfFillExternalBuffer(mask,                                                  \
3430                                                                                                                                    \
3431                                                                             ZCL_EXTRACT_SMART_CARD_COMMAND_ID, "", );
3432
3433 /** @brief Command description for PublishPrice
3434  *
3435  * Command: PublishPrice
3436  * @param providerId INT32U
3437  * @param commandOptions AmiCommandOptions
3438  * @param rateLabel OCTET_STRING
3439  * @param issuerEventId INT32U
3440  * @param currentTime UTC_TIME
3441  * @param unitOfMeasure AmiUnitOfMeasure
3442  * @param currency INT16U
3443  * @param priceTrailingDigitAndPriceTier PriceTrailingDigitAndPriceTier
3444  * @param numberOfPriceTiersAndRegisterTier PriceNumberOfPriceTiersAndRegisterTier
3445  * @param startTime UTC_TIME
3446  * @param durationInMinutes INT16U
3447  * @param price INT32U
3448  * @param priceRatio INT8U
3449  * @param generationPrice INT32U
3450  * @param generationPriceRatio INT8U
3451  * @param alternateCostDelivered INT32U
3452  * @param alternateCostUnit AlternateCostUnit
3453  * @param alternateCostTrailingDigit AlternateCostTrailingDigit
3454  * @param numberOfBlockThresholds INT8U
3455  * @param priceControl PriceControlMask
3456  * @param numberOfGenerationTiers INT8U
3457  * @param generationTier GenerationTier
3458  * @param extendedNumberOfPriceTiers ExtendedNumberOfPriceTiers
3459  * @param extendedPriceTier ExtendedPriceTier
3460  * @param extendedRegisterTier ExtendedRegisterTier
3461  */
3462 #define emberAfFillCommandPriceClusterPublishPrice(                                                                                \
3463     providerId, commandOptions, rateLabel, issuerEventId, currentTime, unitOfMeasure, currency, priceTrailingDigitAndPriceTier,    \
3464     numberOfPriceTiersAndRegisterTier, startTime, durationInMinutes, price, priceRatio, generationPrice, generationPriceRatio,     \
3465     alternateCostDelivered, alternateCostUnit, alternateCostTrailingDigit, numberOfBlockThresholds, priceControl,                  \
3466     numberOfGenerationTiers, generationTier, extendedNumberOfPriceTiers, extendedPriceTier, extendedRegisterTier)                  \
3467     emberAfFillExternalBuffer(mask,                                                                                                \
3468                                                                                                                                    \
3469                               ZCL_PUBLISH_PRICE_COMMAND_ID, "uuuuuuuuuuuuuuuuuuuuuuuuu", providerId, commandOptions, rateLabel,    \
3470                               issuerEventId, currentTime, unitOfMeasure, currency, priceTrailingDigitAndPriceTier,                 \
3471                               numberOfPriceTiersAndRegisterTier, startTime, durationInMinutes, price, priceRatio, generationPrice, \
3472                               generationPriceRatio, alternateCostDelivered, alternateCostUnit, alternateCostTrailingDigit,         \
3473                               numberOfBlockThresholds, priceControl, numberOfGenerationTiers, generationTier,                      \
3474                               extendedNumberOfPriceTiers, extendedPriceTier, extendedRegisterTier);
3475
3476 /** @brief Command description for PublishBlockPeriod
3477  *
3478  * Command: PublishBlockPeriod
3479  * @param providerId INT32U
3480  * @param startTime UTC_TIME
3481  * @param issuerEventId INT32U
3482  * @param numberOfEvents INT8U
3483  * @param blockPeriodStartTime UTC_TIME
3484  * @param blockPeriodDuration INT24U
3485  * @param blockPeriodControl BlockPeriodControl
3486  * @param blockPeriodDurationType BlockPeriodDurationType
3487  * @param tariffType TariffType
3488  * @param tariffResolutionPeriod TariffResolutionPeriod
3489  */
3490 #define emberAfFillCommandPriceClusterPublishBlockPeriod(providerId, startTime, issuerEventId, numberOfEvents,                     \
3491                                                          blockPeriodStartTime, blockPeriodDuration, blockPeriodControl,            \
3492                                                          blockPeriodDurationType, tariffType, tariffResolutionPeriod)              \
3493     emberAfFillExternalBuffer(mask,                                                                                                \
3494                                                                                                                                    \
3495                               ZCL_PUBLISH_BLOCK_PERIOD_COMMAND_ID, "uuuuuuuuuu", providerId, startTime, issuerEventId,             \
3496                               numberOfEvents, blockPeriodStartTime, blockPeriodDuration, blockPeriodControl,                       \
3497                               blockPeriodDurationType, tariffType, tariffResolutionPeriod);
3498
3499 /** @brief Command description for PublishConversionFactor
3500  *
3501  * Command: PublishConversionFactor
3502  * @param issuerEventId INT32U
3503  * @param providerId INT32U
3504  * @param startTime UTC_TIME
3505  * @param issuerEventId INT32U
3506  * @param conversionFactor INT32U
3507  * @param priceAckTime UTC_TIME
3508  * @param conversionFactorTrailingDigit ConversionFactorTrailingDigit
3509  * @param control PriceControlMask
3510  */
3511 #define emberAfFillCommandPriceClusterPublishConversionFactor(                                                                     \
3512     issuerEventId, providerId, startTime, issuerEventId, conversionFactor, priceAckTime, conversionFactorTrailingDigit, control)   \
3513     emberAfFillExternalBuffer(mask,                                                                                                \
3514                                                                                                                                    \
3515                               ZCL_PUBLISH_CONVERSION_FACTOR_COMMAND_ID, "uuuuuuuu", issuerEventId, providerId, startTime,          \
3516                               issuerEventId, conversionFactor, priceAckTime, conversionFactorTrailingDigit, control);
3517
3518 /** @brief Command description for PublishCalorificValue
3519  *
3520  * Command: PublishCalorificValue
3521  * @param issuerEventId INT32U
3522  * @param startTime UTC_TIME
3523  * @param startTime UTC_TIME
3524  * @param numberOfEvents INT8U
3525  * @param calorificValue INT32U
3526  * @param tariffType TariffType
3527  * @param calorificValueUnit CalorificValueUnit
3528  * @param calorificValueTrailingDigit CalorificValueTrailingDigit
3529  */
3530 #define emberAfFillCommandPriceClusterPublishCalorificValue(issuerEventId, startTime, startTime, numberOfEvents, calorificValue,   \
3531                                                             tariffType, calorificValueUnit, calorificValueTrailingDigit)           \
3532     emberAfFillExternalBuffer(mask,                                                                                                \
3533                                                                                                                                    \
3534                               ZCL_PUBLISH_CALORIFIC_VALUE_COMMAND_ID, "uuuuuuuu", issuerEventId, startTime, startTime,             \
3535                               numberOfEvents, calorificValue, tariffType, calorificValueUnit, calorificValueTrailingDigit);
3536
3537 /** @brief Command description for PublishTariffInformation
3538  *
3539  * Command: PublishTariffInformation
3540  * @param providerId INT32U
3541  * @param earliestStartTime UTC_TIME
3542  * @param issuerEventId INT32U
3543  * @param minIssuerEventId INT32U
3544  * @param issuerTariffId INT32U
3545  * @param numberOfCommands INT8U
3546  * @param startTime UTC_TIME
3547  * @param tariffTypeChargingScheme TariffTypeChargingScheme
3548  * @param tariffLabel OCTET_STRING
3549  * @param numberOfPriceTiersInUse INT8U
3550  * @param numberOfBlockThresholdsInUse INT8U
3551  * @param unitOfMeasure AmiUnitOfMeasure
3552  * @param currency INT16U
3553  * @param priceTrailingDigit PriceTrailingDigit
3554  * @param standingCharge INT32U
3555  * @param tierBlockMode TierBlockMode
3556  * @param blockThresholdMultiplier INT24U
3557  * @param blockThresholdDivisor INT24U
3558  */
3559 #define emberAfFillCommandPriceClusterPublishTariffInformation(                                                                    \
3560     providerId, earliestStartTime, issuerEventId, minIssuerEventId, issuerTariffId, numberOfCommands, startTime,                   \
3561     tariffTypeChargingScheme, tariffLabel, numberOfPriceTiersInUse, numberOfBlockThresholdsInUse, unitOfMeasure, currency,         \
3562     priceTrailingDigit, standingCharge, tierBlockMode, blockThresholdMultiplier, blockThresholdDivisor)                            \
3563     emberAfFillExternalBuffer(mask,                                                                                                \
3564                                                                                                                                    \
3565                               ZCL_PUBLISH_TARIFF_INFORMATION_COMMAND_ID, "uuuuuuuuuuuuuuuuuu", providerId, earliestStartTime,      \
3566                               issuerEventId, minIssuerEventId, issuerTariffId, numberOfCommands, startTime,                        \
3567                               tariffTypeChargingScheme, tariffLabel, numberOfPriceTiersInUse, numberOfBlockThresholdsInUse,        \
3568                               unitOfMeasure, currency, priceTrailingDigit, standingCharge, tierBlockMode,                          \
3569                               blockThresholdMultiplier, blockThresholdDivisor);
3570
3571 /** @brief Command description for PublishPriceMatrix
3572  *
3573  * Command: PublishPriceMatrix
3574  * @param providerId INT32U
3575  * @param earliestStartTime UTC_TIME
3576  * @param issuerEventId INT32U
3577  * @param minIssuerEventId INT32U
3578  * @param startTime UTC_TIME
3579  * @param numberOfCommands INT8U
3580  * @param issuerTariffId INT32U
3581  * @param commandIndex INT8U
3582  * @param numberOfCommands INT8U
3583  * @param subPayloadControl PriceMatrixSubPayloadControl
3584  * @param payload PriceMatrixSubPayload []
3585  * @param payloadLen int
3586  */
3587 #define emberAfFillCommandPriceClusterPublishPriceMatrix(providerId, earliestStartTime, issuerEventId, minIssuerEventId,           \
3588                                                          startTime, numberOfCommands, issuerTariffId, commandIndex,                \
3589                                                          numberOfCommands, subPayloadControl, payload, payloadLen)                 \
3590     emberAfFillExternalBuffer(mask,                                                                                                \
3591                                                                                                                                    \
3592                               ZCL_PUBLISH_PRICE_MATRIX_COMMAND_ID, "uuuuuuuuuub", providerId, earliestStartTime, issuerEventId,    \
3593                               minIssuerEventId, startTime, numberOfCommands, issuerTariffId, commandIndex, numberOfCommands,       \
3594                               subPayloadControl, payload, payloadLen);
3595
3596 /** @brief Command description for PublishBlockThresholds
3597  *
3598  * Command: PublishBlockThresholds
3599  * @param providerId INT32U
3600  * @param earliestStartTime UTC_TIME
3601  * @param issuerEventId INT32U
3602  * @param minIssuerEventId INT32U
3603  * @param startTime UTC_TIME
3604  * @param numberOfCommands INT8U
3605  * @param issuerTariffId INT32U
3606  * @param tariffType TariffType
3607  * @param commandIndex INT8U
3608  * @param numberOfCommands INT8U
3609  * @param subPayloadControl BlockThresholdSubPayloadControl
3610  * @param payload BlockThresholdSubPayload []
3611  * @param payloadLen int
3612  */
3613 #define emberAfFillCommandPriceClusterPublishBlockThresholds(                                                                      \
3614     providerId, earliestStartTime, issuerEventId, minIssuerEventId, startTime, numberOfCommands, issuerTariffId, tariffType,       \
3615     commandIndex, numberOfCommands, subPayloadControl, payload, payloadLen)                                                        \
3616     emberAfFillExternalBuffer(mask,                                                                                                \
3617                                                                                                                                    \
3618                               ZCL_PUBLISH_BLOCK_THRESHOLDS_COMMAND_ID, "uuuuuuuuuuub", providerId, earliestStartTime,              \
3619                               issuerEventId, minIssuerEventId, startTime, numberOfCommands, issuerTariffId, tariffType,            \
3620                               commandIndex, numberOfCommands, subPayloadControl, payload, payloadLen);
3621
3622 /** @brief Command description for PublishCO2Value
3623  *
3624  * Command: PublishCO2Value
3625  * @param providerId INT32U
3626  * @param issuerTariffId INT32U
3627  * @param issuerEventId INT32U
3628  * @param startTime UTC_TIME
3629  * @param tariffType TariffType
3630  * @param cO2Value INT32U
3631  * @param cO2ValueUnit CO2Unit
3632  * @param cO2ValueTrailingDigit CO2TrailingDigit
3633  */
3634 #define emberAfFillCommandPriceClusterPublishCO2Value(providerId, issuerTariffId, issuerEventId, startTime, tariffType, cO2Value,  \
3635                                                       cO2ValueUnit, cO2ValueTrailingDigit)                                         \
3636     emberAfFillExternalBuffer(mask,                                                                                                \
3637                                                                                                                                    \
3638                               ZCL_PUBLISH_CO2_VALUE_COMMAND_ID, "uuuuuuuu", providerId, issuerTariffId, issuerEventId, startTime,  \
3639                               tariffType, cO2Value, cO2ValueUnit, cO2ValueTrailingDigit);
3640
3641 /** @brief Command description for PublishTierLabels
3642  *
3643  * Command: PublishTierLabels
3644  * @param providerId INT32U
3645  * @param issuerTariffId INT32U
3646  * @param issuerEventId INT32U
3647  * @param issuerTariffId INT32U
3648  * @param commandIndex INT8U
3649  * @param numberOfCommands INT8U
3650  * @param numberOfLabels INT8U
3651  * @param tierLabelsPayload INT8U []
3652  * @param tierLabelsPayloadLen int
3653  */
3654 #define emberAfFillCommandPriceClusterPublishTierLabels(providerId, issuerTariffId, issuerEventId, issuerTariffId, commandIndex,   \
3655                                                         numberOfCommands, numberOfLabels, tierLabelsPayload, tierLabelsPayloadLen) \
3656     emberAfFillExternalBuffer(mask,                                                                                                \
3657                                                                                                                                    \
3658                               ZCL_PUBLISH_TIER_LABELS_COMMAND_ID, "uuuuuuub", providerId, issuerTariffId, issuerEventId,           \
3659                               issuerTariffId, commandIndex, numberOfCommands, numberOfLabels, tierLabelsPayload,                   \
3660                               tierLabelsPayloadLen);
3661
3662 /** @brief Command description for PublishBillingPeriod
3663  *
3664  * Command: PublishBillingPeriod
3665  * @param providerId INT32U
3666  * @param earliestStartTime UTC_TIME
3667  * @param issuerEventId INT32U
3668  * @param minIssuerEventId INT32U
3669  * @param billingPeriodStartTime UTC_TIME
3670  * @param numberOfCommands INT8U
3671  * @param billingPeriodDuration BillingPeriodDuration
3672  * @param tariffType TariffType
3673  * @param billingPeriodDurationType BillingPeriodDurationType
3674  * @param tariffType TariffType
3675  */
3676 #define emberAfFillCommandPriceClusterPublishBillingPeriod(providerId, earliestStartTime, issuerEventId, minIssuerEventId,         \
3677                                                            billingPeriodStartTime, numberOfCommands, billingPeriodDuration,        \
3678                                                            tariffType, billingPeriodDurationType, tariffType)                      \
3679     emberAfFillExternalBuffer(mask,                                                                                                \
3680                                                                                                                                    \
3681                               ZCL_PUBLISH_BILLING_PERIOD_COMMAND_ID, "uuuuuuuuuu", providerId, earliestStartTime, issuerEventId,   \
3682                               minIssuerEventId, billingPeriodStartTime, numberOfCommands, billingPeriodDuration, tariffType,       \
3683                               billingPeriodDurationType, tariffType);
3684
3685 /** @brief Command description for PublishConsolidatedBill
3686  *
3687  * Command: PublishConsolidatedBill
3688  * @param providerId INT32U
3689  * @param issuerTariffId INT32U
3690  * @param issuerEventId INT32U
3691  * @param billingPeriodStartTime UTC_TIME
3692  * @param billingPeriodDuration BillingPeriodDuration
3693  * @param billingPeriodDurationType BillingPeriodDurationType
3694  * @param tariffType TariffType
3695  * @param consolidatedBill INT32U
3696  * @param currency INT16U
3697  * @param billTrailingDigit BillTrailingDigit
3698  */
3699 #define emberAfFillCommandPriceClusterPublishConsolidatedBill(providerId, issuerTariffId, issuerEventId, billingPeriodStartTime,   \
3700                                                               billingPeriodDuration, billingPeriodDurationType, tariffType,        \
3701                                                               consolidatedBill, currency, billTrailingDigit)                       \
3702     emberAfFillExternalBuffer(mask,                                                                                                \
3703                                                                                                                                    \
3704                               ZCL_PUBLISH_CONSOLIDATED_BILL_COMMAND_ID, "uuuuuuuuuu", providerId, issuerTariffId, issuerEventId,   \
3705                               billingPeriodStartTime, billingPeriodDuration, billingPeriodDurationType, tariffType,                \
3706                               consolidatedBill, currency, billTrailingDigit);
3707
3708 /** @brief Command description for PublishCppEvent
3709  *
3710  * Command: PublishCppEvent
3711  * @param providerId INT32U
3712  * @param earliestStartTime UTC_TIME
3713  * @param issuerEventId INT32U
3714  * @param minIssuerEventId INT32U
3715  * @param startTime UTC_TIME
3716  * @param numberOfCommands INT8U
3717  * @param durationInMinutes INT16U
3718  * @param tariffType TariffType
3719  * @param tariffType TariffType
3720  * @param cppPriceTier CppPriceTier
3721  * @param cppAuth PublishCppEventCppAuth
3722  */
3723 #define emberAfFillCommandPriceClusterPublishCppEvent(providerId, earliestStartTime, issuerEventId, minIssuerEventId, startTime,   \
3724                                                       numberOfCommands, durationInMinutes, tariffType, tariffType, cppPriceTier,   \
3725                                                       cppAuth)                                                                     \
3726     emberAfFillExternalBuffer(mask,                                                                                                \
3727                                                                                                                                    \
3728                               ZCL_PUBLISH_CPP_EVENT_COMMAND_ID, "uuuuuuuuuuu", providerId, earliestStartTime, issuerEventId,       \
3729                               minIssuerEventId, startTime, numberOfCommands, durationInMinutes, tariffType, tariffType,            \
3730                               cppPriceTier, cppAuth);
3731
3732 /** @brief Command description for PublishCreditPayment
3733  *
3734  * Command: PublishCreditPayment
3735  * @param providerId INT32U
3736  * @param earliestStartTime UTC_TIME
3737  * @param issuerEventId INT32U
3738  * @param minIssuerEventId INT32U
3739  * @param creditPaymentDueDate UTC_TIME
3740  * @param numberOfCommands INT8U
3741  * @param creditPaymentOverDueAmount INT32U
3742  * @param tariffType TariffType
3743  * @param creditPaymentStatus CreditPaymentStatus
3744  * @param creditPayment INT32U
3745  * @param creditPaymentDate UTC_TIME
3746  * @param creditPaymentRef OCTET_STRING
3747  */
3748 #define emberAfFillCommandPriceClusterPublishCreditPayment(                                                                        \
3749     providerId, earliestStartTime, issuerEventId, minIssuerEventId, creditPaymentDueDate, numberOfCommands,                        \
3750     creditPaymentOverDueAmount, tariffType, creditPaymentStatus, creditPayment, creditPaymentDate, creditPaymentRef)               \
3751     emberAfFillExternalBuffer(mask,                                                                                                \
3752                                                                                                                                    \
3753                               ZCL_PUBLISH_CREDIT_PAYMENT_COMMAND_ID, "uuuuuuuuuuuu", providerId, earliestStartTime, issuerEventId, \
3754                               minIssuerEventId, creditPaymentDueDate, numberOfCommands, creditPaymentOverDueAmount, tariffType,    \
3755                               creditPaymentStatus, creditPayment, creditPaymentDate, creditPaymentRef);
3756
3757 /** @brief Command description for PublishCurrencyConversion
3758  *
3759  * Command: PublishCurrencyConversion
3760  * @param providerId INT32U
3761  * @param issuerEventId INT32U
3762  * @param issuerEventId INT32U
3763  * @param cppAuth CppEventResponseCppAuth
3764  * @param startTime UTC_TIME
3765  * @param oldCurrency INT16U
3766  * @param newCurrency INT16U
3767  * @param conversionFactor INT32U
3768  * @param conversionFactorTrailingDigit ConversionFactorTrailingDigit
3769  * @param currencyChangeControlFlags CurrencyChangeControl
3770  */
3771 #define emberAfFillCommandPriceClusterPublishCurrencyConversion(providerId, issuerEventId, issuerEventId, cppAuth, startTime,      \
3772                                                                 oldCurrency, newCurrency, conversionFactor,                        \
3773                                                                 conversionFactorTrailingDigit, currencyChangeControlFlags)         \
3774     emberAfFillExternalBuffer(mask,                                                                                                \
3775                                                                                                                                    \
3776                               ZCL_PUBLISH_CURRENCY_CONVERSION_COMMAND_ID, "uuuuuuuuuu", providerId, issuerEventId, issuerEventId,  \
3777                               cppAuth, startTime, oldCurrency, newCurrency, conversionFactor, conversionFactorTrailingDigit,       \
3778                               currencyChangeControlFlags);
3779
3780 /** @brief Command description for CancelTariff
3781  *
3782  * Command: CancelTariff
3783  * @param providerId INT32U
3784  * @param latestEndTime UTC_TIME
3785  * @param issuerTariffId INT32U
3786  * @param numberOfRecords INT8U
3787  * @param tariffType TariffType
3788  */
3789 #define emberAfFillCommandPriceClusterCancelTariff(providerId, latestEndTime, issuerTariffId, numberOfRecords, tariffType)         \
3790     emberAfFillExternalBuffer(mask,                                                                                                \
3791                                                                                                                                    \
3792                               ZCL_CANCEL_TARIFF_COMMAND_ID, "uuuuu", providerId, latestEndTime, issuerTariffId, numberOfRecords,   \
3793                               tariffType);
3794
3795 /** @brief Command description for GetCurrencyConversionCommand
3796  *
3797  * Command: GetCurrencyConversionCommand
3798  */
3799 #define emberAfFillCommandPriceClusterGetCurrencyConversionCommand()                                                               \
3800     emberAfFillExternalBuffer(mask,                                                                                                \
3801                                                                                                                                    \
3802                               ZCL_GET_CURRENCY_CONVERSION_COMMAND_COMMAND_ID, "", );
3803
3804 /** @brief Command description for GetTariffCancellation
3805  *
3806  * Command: GetTariffCancellation
3807  */
3808 #define emberAfFillCommandPriceClusterGetTariffCancellation()                                                                      \
3809     emberAfFillExternalBuffer(mask,                                                                                                \
3810                                                                                                                                    \
3811                               ZCL_GET_TARIFF_CANCELLATION_COMMAND_ID, "", );
3812
3813 /** @brief Command description for LoadControlEvent
3814  *
3815  * Command: LoadControlEvent
3816  * @param issuerEventId INT32U
3817  * @param issuerEventId INT32U
3818  * @param deviceClass AmiDeviceClass
3819  * @param eventStatus AmiEventStatus
3820  * @param utilityEnrollmentGroup INT8U
3821  * @param eventStatusTime UTC_TIME
3822  * @param startTime UTC_TIME
3823  * @param criticalityLevelApplied AmiCriticalityLevel
3824  * @param durationInMinutes INT16U
3825  * @param coolingTemperatureSetPointApplied INT16U
3826  * @param criticalityLevel AmiCriticalityLevel
3827  * @param heatingTemperatureSetPointApplied INT16U
3828  * @param coolingTemperatureOffset INT8U
3829  * @param averageLoadAdjustmentPercentageApplied INT8S
3830  * @param heatingTemperatureOffset INT8U
3831  * @param dutyCycleApplied INT8U
3832  * @param coolingTemperatureSetPoint INT16S
3833  * @param eventControl AmiEventControl
3834  * @param heatingTemperatureSetPoint INT16S
3835  * @param signatureType SignatureType
3836  * @param averageLoadAdjustmentPercentage INT8S
3837  * @param signature Signature
3838  * @param dutyCycle INT8U
3839  * @param eventControl AmiEventControl
3840  */
3841 #define emberAfFillCommandDemand                                                                                                   \
3842     Response and Load ControlClusterLoadControlEvent(                                                                              \
3843         issuerEventId, issuerEventId, deviceClass, eventStatus, utilityEnrollmentGroup, eventStatusTime, startTime,                \
3844         criticalityLevelApplied, durationInMinutes, coolingTemperatureSetPointApplied, criticalityLevel,                           \
3845         heatingTemperatureSetPointApplied, coolingTemperatureOffset, averageLoadAdjustmentPercentageApplied,                       \
3846         heatingTemperatureOffset, dutyCycleApplied, coolingTemperatureSetPoint, eventControl, heatingTemperatureSetPoint,          \
3847         signatureType, averageLoadAdjustmentPercentage, signature, dutyCycle, eventControl)                                        \
3848         emberAfFillExternalBuffer(mask,                                                                                            \
3849                                                                                                                                    \
3850                                   ZCL_LOAD_CONTROL_EVENT_COMMAND_ID, "uuuuuuuuuuuuuuuuuuuuuuuu", issuerEventId, issuerEventId,     \
3851                                   deviceClass, eventStatus, utilityEnrollmentGroup, eventStatusTime, startTime,                    \
3852                                   criticalityLevelApplied, durationInMinutes, coolingTemperatureSetPointApplied, criticalityLevel, \
3853                                   heatingTemperatureSetPointApplied, coolingTemperatureOffset,                                     \
3854                                   averageLoadAdjustmentPercentageApplied, heatingTemperatureOffset, dutyCycleApplied,              \
3855                                   coolingTemperatureSetPoint, eventControl, heatingTemperatureSetPoint, signatureType,             \
3856                                   averageLoadAdjustmentPercentage, signature, dutyCycle, eventControl);
3857
3858 /** @brief Command description for CancelLoadControlEvent
3859  *
3860  * Command: CancelLoadControlEvent
3861  * @param issuerEventId INT32U
3862  * @param startTime UTC_TIME
3863  * @param deviceClass AmiDeviceClass
3864  * @param numberOfEvents INT8U
3865  * @param utilityEnrollmentGroup INT8U
3866  * @param issuerEventId INT32U
3867  * @param cancelControl AmiCancelControl
3868  * @param effectiveTime UTC_TIME
3869  */
3870 #define emberAfFillCommandDemand                                                                                                   \
3871     Response and Load ControlClusterCancelLoadControlEvent(issuerEventId, startTime, deviceClass, numberOfEvents,                  \
3872                                                            utilityEnrollmentGroup, issuerEventId, cancelControl, effectiveTime)    \
3873         emberAfFillExternalBuffer(mask,                                                                                            \
3874                                                                                                                                    \
3875                                   ZCL_CANCEL_LOAD_CONTROL_EVENT_COMMAND_ID, "uuuuuuuu", issuerEventId, startTime, deviceClass,     \
3876                                   numberOfEvents, utilityEnrollmentGroup, issuerEventId, cancelControl, effectiveTime);
3877
3878 /** @brief Command description for CancelAllLoadControlEvents
3879  *
3880  * Command: CancelAllLoadControlEvents
3881  * @param cancelControl AmiCancelControl
3882  */
3883 #define emberAfFillCommandDemand                                                                                                   \
3884     Response and Load ControlClusterCancelAllLoadControlEvents(cancelControl)                                                      \
3885         emberAfFillExternalBuffer(mask,                                                                                            \
3886                                                                                                                                    \
3887                                   ZCL_CANCEL_ALL_LOAD_CONTROL_EVENTS_COMMAND_ID, "u", cancelControl);
3888
3889 /** @brief Command description for GetProfileResponse
3890  *
3891  * Command: GetProfileResponse
3892  * @param endTime UTC_TIME
3893  * @param intervalChannel AmiIntervalChannel
3894  * @param status AmiGetProfileStatus
3895  * @param endTime UTC_TIME
3896  * @param profileIntervalPeriod AmiIntervalPeriod
3897  * @param numberOfPeriods INT8U
3898  * @param numberOfPeriodsDelivered INT8U
3899  * @param intervals INT24U []
3900  * @param intervalsLen int
3901  */
3902 #define emberAfFillCommandSimple                                                                                                   \
3903     MeteringClusterGetProfileResponse(endTime, intervalChannel, status, endTime, profileIntervalPeriod, numberOfPeriods,           \
3904                                       numberOfPeriodsDelivered, intervals, intervalsLen)                                           \
3905         emberAfFillExternalBuffer(mask,                                                                                            \
3906                                                                                                                                    \
3907                                   ZCL_GET_PROFILE_RESPONSE_COMMAND_ID, "uuuuuuub", endTime, intervalChannel, status, endTime,      \
3908                                   profileIntervalPeriod, numberOfPeriods, numberOfPeriodsDelivered, intervals, intervalsLen);
3909
3910 /** @brief Command description for RequestMirror
3911  *
3912  * Command: RequestMirror
3913  * @param endpointId INT16U
3914  */
3915 #define emberAfFillCommandSimple                                                                                                   \
3916     MeteringClusterRequestMirror(endpointId) emberAfFillExternalBuffer(mask,                                                       \
3917                                                                                                                                    \
3918                                                                        ZCL_REQUEST_MIRROR_COMMAND_ID, "u", endpointId);
3919
3920 /** @brief Command description for RemoveMirror
3921  *
3922  * Command: RemoveMirror
3923  * @param endpointId INT16U
3924  */
3925 #define emberAfFillCommandSimple                                                                                                   \
3926     MeteringClusterRemoveMirror(endpointId) emberAfFillExternalBuffer(mask,                                                        \
3927                                                                                                                                    \
3928                                                                       ZCL_REMOVE_MIRROR_COMMAND_ID, "u", endpointId);
3929
3930 /** @brief Command description for RequestFastPollModeResponse
3931  *
3932  * Command: RequestFastPollModeResponse
3933  * @param appliedUpdatePeriod INT8U
3934  * @param fastPollUpdatePeriod INT8U
3935  * @param fastPollModeEndtime UTC_TIME
3936  * @param duration INT8U
3937  */
3938 #define emberAfFillCommandSimple                                                                                                   \
3939     MeteringClusterRequestFastPollModeResponse(appliedUpdatePeriod, fastPollUpdatePeriod, fastPollModeEndtime, duration)           \
3940         emberAfFillExternalBuffer(mask,                                                                                            \
3941                                                                                                                                    \
3942                                   ZCL_REQUEST_FAST_POLL_MODE_RESPONSE_COMMAND_ID, "uuuu", appliedUpdatePeriod,                     \
3943                                   fastPollUpdatePeriod, fastPollModeEndtime, duration);
3944
3945 /** @brief Command description for ScheduleSnapshotResponse
3946  *
3947  * Command: ScheduleSnapshotResponse
3948  * @param issuerEventId INT32U
3949  * @param issuerEventId INT32U
3950  * @param snapshotResponsePayload SnapshotResponsePayload []
3951  * @param snapshotResponsePayloadLen int
3952  * @param commandIndex INT8U
3953  * @param commandCount INT8U
3954  * @param snapshotSchedulePayload SnapshotSchedulePayload []
3955  * @param snapshotSchedulePayloadLen int
3956  */
3957 #define emberAfFillCommandSimple                                                                                                   \
3958     MeteringClusterScheduleSnapshotResponse(issuerEventId, issuerEventId, snapshotResponsePayload, snapshotResponsePayloadLen,     \
3959                                             commandIndex, commandCount, snapshotSchedulePayload, snapshotSchedulePayloadLen)       \
3960         emberAfFillExternalBuffer(mask,                                                                                            \
3961                                                                                                                                    \
3962                                   ZCL_SCHEDULE_SNAPSHOT_RESPONSE_COMMAND_ID, "uubuub", issuerEventId, issuerEventId,               \
3963                                   snapshotResponsePayload, snapshotResponsePayloadLen, commandIndex, commandCount,                 \
3964                                   snapshotSchedulePayload, snapshotSchedulePayloadLen);
3965
3966 /** @brief Command description for TakeSnapshotResponse
3967  *
3968  * Command: TakeSnapshotResponse
3969  * @param snapshotId INT32U
3970  * @param snapshotCause SnapshotCause
3971  * @param snapshotConfirmation SnapshotConfirmation
3972  */
3973 #define emberAfFillCommandSimple                                                                                                   \
3974     MeteringClusterTakeSnapshotResponse(snapshotId, snapshotCause, snapshotConfirmation)                                           \
3975         emberAfFillExternalBuffer(mask,                                                                                            \
3976                                                                                                                                    \
3977                                   ZCL_TAKE_SNAPSHOT_RESPONSE_COMMAND_ID, "uuu", snapshotId, snapshotCause, snapshotConfirmation);
3978
3979 /** @brief Command description for PublishSnapshot
3980  *
3981  * Command: PublishSnapshot
3982  * @param snapshotId INT32U
3983  * @param earliestStartTime UTC_TIME
3984  * @param snapshotTime UTC_TIME
3985  * @param latestEndTime UTC_TIME
3986  * @param totalSnapshotsFound INT8U
3987  * @param snapshotOffset INT8U
3988  * @param commandIndex INT8U
3989  * @param snapshotCause SnapshotCause
3990  * @param totalCommands INT8U
3991  * @param snapshotCause SnapshotCause
3992  * @param snapshotPayloadType SnapshotPayloadType
3993  * @param snapshotPayload INT8U []
3994  * @param snapshotPayloadLen int
3995  */
3996 #define emberAfFillCommandSimple                                                                                                   \
3997     MeteringClusterPublishSnapshot(snapshotId, earliestStartTime, snapshotTime, latestEndTime, totalSnapshotsFound,                \
3998                                    snapshotOffset, commandIndex, snapshotCause, totalCommands, snapshotCause, snapshotPayloadType, \
3999                                    snapshotPayload, snapshotPayloadLen)                                                            \
4000         emberAfFillExternalBuffer(mask,                                                                                            \
4001                                                                                                                                    \
4002                                   ZCL_PUBLISH_SNAPSHOT_COMMAND_ID, "uuuuuuuuuuub", snapshotId, earliestStartTime, snapshotTime,    \
4003                                   latestEndTime, totalSnapshotsFound, snapshotOffset, commandIndex, snapshotCause, totalCommands,  \
4004                                   snapshotCause, snapshotPayloadType, snapshotPayload, snapshotPayloadLen);
4005
4006 /** @brief Command description for GetSampledDataResponse
4007  *
4008  * Command: GetSampledDataResponse
4009  * @param sampleId INT16U
4010  * @param issuerEventId INT32U
4011  * @param sampleStartTime UTC_TIME
4012  * @param startSamplingTime UTC_TIME
4013  * @param sampleType SampleType
4014  * @param sampleType SampleType
4015  * @param sampleRequestInterval INT16U
4016  * @param sampleRequestInterval INT16U
4017  * @param numberOfSamples INT16U
4018  * @param maxNumberOfSamples INT16U
4019  * @param samples INT24U []
4020  * @param samplesLen int
4021  */
4022 #define emberAfFillCommandSimple                                                                                                   \
4023     MeteringClusterGetSampledDataResponse(sampleId, issuerEventId, sampleStartTime, startSamplingTime, sampleType, sampleType,     \
4024                                           sampleRequestInterval, sampleRequestInterval, numberOfSamples, maxNumberOfSamples,       \
4025                                           samples, samplesLen)                                                                     \
4026         emberAfFillExternalBuffer(mask,                                                                                            \
4027                                                                                                                                    \
4028                                   ZCL_GET_SAMPLED_DATA_RESPONSE_COMMAND_ID, "uuuuuuuuuub", sampleId, issuerEventId,                \
4029                                   sampleStartTime, startSamplingTime, sampleType, sampleType, sampleRequestInterval,               \
4030                                   sampleRequestInterval, numberOfSamples, maxNumberOfSamples, samples, samplesLen);
4031
4032 /** @brief Command description for ConfigureMirror
4033  *
4034  * Command: ConfigureMirror
4035  * @param issuerEventId INT32U
4036  * @param sampleId INT16U
4037  * @param reportingInterval INT24U
4038  * @param earliestSampleTime UTC_TIME
4039  * @param mirrorNotificationReporting BOOLEAN
4040  * @param sampleType SampleType
4041  * @param notificationScheme INT8U
4042  * @param numberOfSamples INT16U
4043  */
4044 #define emberAfFillCommandSimple                                                                                                   \
4045     MeteringClusterConfigureMirror(issuerEventId, sampleId, reportingInterval, earliestSampleTime, mirrorNotificationReporting,    \
4046                                    sampleType, notificationScheme, numberOfSamples)                                                \
4047         emberAfFillExternalBuffer(mask,                                                                                            \
4048                                                                                                                                    \
4049                                   ZCL_CONFIGURE_MIRROR_COMMAND_ID, "uuuuuuuu", issuerEventId, sampleId, reportingInterval,         \
4050                                   earliestSampleTime, mirrorNotificationReporting, sampleType, notificationScheme,                 \
4051                                   numberOfSamples);
4052
4053 /** @brief Command description for ConfigureNotificationScheme
4054  *
4055  * Command: ConfigureNotificationScheme
4056  * @param issuerEventId INT32U
4057  * @param notificationScheme INT8U
4058  * @param notificationScheme INT8U
4059  * @param notificationFlags BITMAP32 []
4060  * @param notificationFlagsLen int
4061  * @param notificationFlagOrder BITMAP32
4062  */
4063 #define emberAfFillCommandSimple                                                                                                   \
4064     MeteringClusterConfigureNotificationScheme(issuerEventId, notificationScheme, notificationScheme, notificationFlags,           \
4065                                                notificationFlagsLen, notificationFlagOrder)                                        \
4066         emberAfFillExternalBuffer(mask,                                                                                            \
4067                                                                                                                                    \
4068                                   ZCL_CONFIGURE_NOTIFICATION_SCHEME_COMMAND_ID, "uuubu", issuerEventId, notificationScheme,        \
4069                                   notificationScheme, notificationFlags, notificationFlagsLen, notificationFlagOrder);
4070
4071 /** @brief Command description for ConfigureNotificationFlags
4072  *
4073  * Command: ConfigureNotificationFlags
4074  * @param issuerEventId INT32U
4075  * @param providerId INT32U
4076  * @param notificationScheme INT8U
4077  * @param issuerEventId INT32U
4078  * @param notificationFlagAttributeId INT16U
4079  * @param clusterId INT16U
4080  * @param manufacturerCode INT16U
4081  * @param numberOfCommands INT8U
4082  * @param commandIds INT8U []
4083  * @param commandIdsLen int
4084  */
4085 #define emberAfFillCommandSimple                                                                                                   \
4086     MeteringClusterConfigureNotificationFlags(issuerEventId, providerId, notificationScheme, issuerEventId,                        \
4087                                               notificationFlagAttributeId, clusterId, manufacturerCode, numberOfCommands,          \
4088                                               commandIds, commandIdsLen)                                                           \
4089         emberAfFillExternalBuffer(mask,                                                                                            \
4090                                                                                                                                    \
4091                                   ZCL_CONFIGURE_NOTIFICATION_FLAGS_COMMAND_ID, "uuuuuuuub", issuerEventId, providerId,             \
4092                                   notificationScheme, issuerEventId, notificationFlagAttributeId, clusterId, manufacturerCode,     \
4093                                   numberOfCommands, commandIds, commandIdsLen);
4094
4095 /** @brief Command description for GetNotifiedMessage
4096  *
4097  * Command: GetNotifiedMessage
4098  * @param notificationScheme INT8U
4099  * @param providerId INT32U
4100  * @param notificationFlagAttributeId INT16U
4101  * @param issuerEventId INT32U
4102  * @param notificationFlagsN BITMAP32
4103  * @param requestDateTime UTC_TIME
4104  * @param implementationDateTime UTC_TIME
4105  * @param proposedSupplyStatus MeteringSupplyStatus
4106  * @param supplyControlBits SupplyControlBits
4107  */
4108 #define emberAfFillCommandSimple                                                                                                   \
4109     MeteringClusterGetNotifiedMessage(notificationScheme, providerId, notificationFlagAttributeId, issuerEventId,                  \
4110                                       notificationFlagsN, requestDateTime, implementationDateTime, proposedSupplyStatus,           \
4111                                       supplyControlBits)                                                                           \
4112         emberAfFillExternalBuffer(mask,                                                                                            \
4113                                                                                                                                    \
4114                                   ZCL_GET_NOTIFIED_MESSAGE_COMMAND_ID, "uuuuuuuuu", notificationScheme, providerId,                \
4115                                   notificationFlagAttributeId, issuerEventId, notificationFlagsN, requestDateTime,                 \
4116                                   implementationDateTime, proposedSupplyStatus, supplyControlBits);
4117
4118 /** @brief Command description for SupplyStatusResponse
4119  *
4120  * Command: SupplyStatusResponse
4121  * @param providerId INT32U
4122  * @param proposedSupplyStatus ProposedSupplyStatus
4123  * @param issuerEventId INT32U
4124  * @param implementationDateTime UTC_TIME
4125  * @param supplyStatus MeteringSupplyStatus
4126  */
4127 #define emberAfFillCommandSimple                                                                                                   \
4128     MeteringClusterSupplyStatusResponse(providerId, proposedSupplyStatus, issuerEventId, implementationDateTime, supplyStatus)     \
4129         emberAfFillExternalBuffer(mask,                                                                                            \
4130                                                                                                                                    \
4131                                   ZCL_SUPPLY_STATUS_RESPONSE_COMMAND_ID, "uuuuu", providerId, proposedSupplyStatus, issuerEventId, \
4132                                   implementationDateTime, supplyStatus);
4133
4134 /** @brief Command description for StartSamplingResponse
4135  *
4136  * Command: StartSamplingResponse
4137  * @param sampleId INT16U
4138  * @param issuerEventId INT32U
4139  * @param supplyTamperState SupplyStatus
4140  * @param supplyDepletionState SupplyStatus
4141  * @param supplyUncontrolledFlowState SupplyStatus
4142  * @param loadLimitSupplyState SupplyStatus
4143  */
4144 #define emberAfFillCommandSimple                                                                                                   \
4145     MeteringClusterStartSamplingResponse(sampleId, issuerEventId, supplyTamperState, supplyDepletionState,                         \
4146                                          supplyUncontrolledFlowState, loadLimitSupplyState)                                        \
4147         emberAfFillExternalBuffer(mask,                                                                                            \
4148                                                                                                                                    \
4149                                   ZCL_START_SAMPLING_RESPONSE_COMMAND_ID, "uuuuuu", sampleId, issuerEventId, supplyTamperState,    \
4150                                   supplyDepletionState, supplyUncontrolledFlowState, loadLimitSupplyState);
4151
4152 /** @brief Command description for SetUncontrolledFlowThreshold
4153  *
4154  * Command: SetUncontrolledFlowThreshold
4155  * @param providerId INT32U
4156  * @param issuerEventId INT32U
4157  * @param uncontrolledFlowThreshold INT16U
4158  * @param unitOfMeasure AmiUnitOfMeasure
4159  * @param multiplier INT16U
4160  * @param divisor INT16U
4161  * @param stabilisationPeriod INT8U
4162  * @param measurementPeriod INT16U
4163  */
4164 #define emberAfFillCommandSimple                                                                                                   \
4165     MeteringClusterSetUncontrolledFlowThreshold(providerId, issuerEventId, uncontrolledFlowThreshold, unitOfMeasure, multiplier,   \
4166                                                 divisor, stabilisationPeriod, measurementPeriod)                                   \
4167         emberAfFillExternalBuffer(mask,                                                                                            \
4168                                                                                                                                    \
4169                                   ZCL_SET_UNCONTROLLED_FLOW_THRESHOLD_COMMAND_ID, "uuuuuuuu", providerId, issuerEventId,           \
4170                                   uncontrolledFlowThreshold, unitOfMeasure, multiplier, divisor, stabilisationPeriod,              \
4171                                   measurementPeriod);
4172
4173 /** @brief Command description for GetLastMessage
4174  *
4175  * Command: GetLastMessage
4176  * @param messageId INT32U
4177  * @param messageControl MessagingControlMask
4178  * @param startTime UTC_TIME
4179  * @param durationInMinutes INT16U
4180  * @param message CHAR_STRING
4181  * @param optionalExtendedMessageControl MessagingExtendedControlMask
4182  */
4183 #define emberAfFillCommandMessagingClusterGetLastMessage(messageId, messageControl, startTime, durationInMinutes, message,         \
4184                                                          optionalExtendedMessageControl)                                           \
4185     emberAfFillExternalBuffer(mask,                                                                                                \
4186                                                                                                                                    \
4187                               ZCL_GET_LAST_MESSAGE_COMMAND_ID, "uuuuuu", messageId, messageControl, startTime, durationInMinutes,  \
4188                               message, optionalExtendedMessageControl);
4189
4190 /** @brief Command description for CancelMessage
4191  *
4192  * Command: CancelMessage
4193  * @param messageId INT32U
4194  * @param messageId INT32U
4195  * @param messageControl MessagingControlMask
4196  * @param confirmationTime UTC_TIME
4197  * @param messageConfirmationControl BITMAP8
4198  * @param messageResponse OCTET_STRING
4199  */
4200 #define emberAfFillCommandMessagingClusterCancelMessage(messageId, messageId, messageControl, confirmationTime,                    \
4201                                                         messageConfirmationControl, messageResponse)                               \
4202     emberAfFillExternalBuffer(mask,                                                                                                \
4203                                                                                                                                    \
4204                               ZCL_CANCEL_MESSAGE_COMMAND_ID, "uuuuuu", messageId, messageId, messageControl, confirmationTime,     \
4205                               messageConfirmationControl, messageResponse);
4206
4207 /** @brief Command description for DisplayProtectedMessage
4208  *
4209  * Command: DisplayProtectedMessage
4210  * @param messageId INT32U
4211  * @param earliestImplementationTime UTC_TIME
4212  * @param messageControl MessagingControlMask
4213  * @param startTime UTC_TIME
4214  * @param durationInMinutes INT16U
4215  * @param message CHAR_STRING
4216  * @param optionalExtendedMessageControl MessagingExtendedControlMask
4217  */
4218 #define emberAfFillCommandMessagingClusterDisplayProtectedMessage(                                                                 \
4219     messageId, earliestImplementationTime, messageControl, startTime, durationInMinutes, message, optionalExtendedMessageControl)  \
4220     emberAfFillExternalBuffer(mask,                                                                                                \
4221                                                                                                                                    \
4222                               ZCL_DISPLAY_PROTECTED_MESSAGE_COMMAND_ID, "uuuuuuu", messageId, earliestImplementationTime,          \
4223                               messageControl, startTime, durationInMinutes, message, optionalExtendedMessageControl);
4224
4225 /** @brief Command description for CancelAllMessages
4226  *
4227  * Command: CancelAllMessages
4228  * @param implementationDateTime UTC_TIME
4229  */
4230 #define emberAfFillCommandMessagingClusterCancelAllMessages(implementationDateTime)                                                \
4231     emberAfFillExternalBuffer(mask,                                                                                                \
4232                                                                                                                                    \
4233                               ZCL_CANCEL_ALL_MESSAGES_COMMAND_ID, "u", implementationDateTime);
4234
4235 /** @brief Command description for RequestTunnel
4236  *
4237  * Command: RequestTunnel
4238  * @param protocolId INT8U
4239  * @param tunnelId INT16U
4240  * @param manufacturerCode INT16U
4241  * @param tunnelStatus TunnelingTunnelStatus
4242  * @param flowControlSupport BOOLEAN
4243  * @param maximumIncomingTransferSize INT16U
4244  * @param maximumIncomingTransferSize INT16U
4245  */
4246 #define emberAfFillCommandTunnelingClusterRequestTunnel(protocolId, tunnelId, manufacturerCode, tunnelStatus, flowControlSupport,  \
4247                                                         maximumIncomingTransferSize, maximumIncomingTransferSize)                  \
4248     emberAfFillExternalBuffer(mask,                                                                                                \
4249                                                                                                                                    \
4250                               ZCL_REQUEST_TUNNEL_COMMAND_ID, "uuuuuuu", protocolId, tunnelId, manufacturerCode, tunnelStatus,      \
4251                               flowControlSupport, maximumIncomingTransferSize, maximumIncomingTransferSize);
4252
4253 /** @brief Command description for CloseTunnel
4254  *
4255  * Command: CloseTunnel
4256  * @param tunnelId INT16U
4257  * @param tunnelId INT16U
4258  * @param data INT8U []
4259  * @param dataLen int
4260  */
4261 #define emberAfFillCommandTunnelingClusterCloseTunnel(tunnelId, tunnelId, data, dataLen)                                           \
4262     emberAfFillExternalBuffer(mask,                                                                                                \
4263                                                                                                                                    \
4264                               ZCL_CLOSE_TUNNEL_COMMAND_ID, "uub", tunnelId, tunnelId, data, dataLen);
4265
4266 /** @brief Command description for TransferDataClientToServer
4267  *
4268  * Command: TransferDataClientToServer
4269  * @param tunnelId INT16U
4270  * @param tunnelId INT16U
4271  * @param data INT8U []
4272  * @param dataLen int
4273  * @param transferDataStatus TunnelingTransferDataStatus
4274  */
4275 #define emberAfFillCommandTunnelingClusterTransferDataClientToServer(tunnelId, tunnelId, data, dataLen, transferDataStatus)        \
4276     emberAfFillExternalBuffer(mask,                                                                                                \
4277                                                                                                                                    \
4278                               ZCL_TRANSFER_DATA_CLIENT_TO_SERVER_COMMAND_ID, "uubu", tunnelId, tunnelId, data, dataLen,            \
4279                               transferDataStatus);
4280
4281 /** @brief Command description for TransferDataErrorClientToServer
4282  *
4283  * Command: TransferDataErrorClientToServer
4284  * @param tunnelId INT16U
4285  * @param tunnelId INT16U
4286  * @param transferDataStatus TunnelingTransferDataStatus
4287  * @param numberOfBytesLeft INT16U
4288  */
4289 #define emberAfFillCommandTunnelingClusterTransferDataErrorClientToServer(tunnelId, tunnelId, transferDataStatus,                  \
4290                                                                           numberOfBytesLeft)                                       \
4291     emberAfFillExternalBuffer(mask,                                                                                                \
4292                                                                                                                                    \
4293                               ZCL_TRANSFER_DATA_ERROR_CLIENT_TO_SERVER_COMMAND_ID, "uuuu", tunnelId, tunnelId, transferDataStatus, \
4294                               numberOfBytesLeft);
4295
4296 /** @brief Command description for AckTransferDataClientToServer
4297  *
4298  * Command: AckTransferDataClientToServer
4299  * @param tunnelId INT16U
4300  * @param tunnelId INT16U
4301  * @param numberOfBytesLeft INT16U
4302  * @param numberOfOctetsLeft INT16U
4303  */
4304 #define emberAfFillCommandTunnelingClusterAckTransferDataClientToServer(tunnelId, tunnelId, numberOfBytesLeft, numberOfOctetsLeft) \
4305     emberAfFillExternalBuffer(mask,                                                                                                \
4306                                                                                                                                    \
4307                               ZCL_ACK_TRANSFER_DATA_CLIENT_TO_SERVER_COMMAND_ID, "uuuu", tunnelId, tunnelId, numberOfBytesLeft,    \
4308                               numberOfOctetsLeft);
4309
4310 /** @brief Command description for ReadyDataClientToServer
4311  *
4312  * Command: ReadyDataClientToServer
4313  * @param tunnelId INT16U
4314  * @param protocolListComplete BOOLEAN
4315  * @param numberOfOctetsLeft INT16U
4316  * @param protocolCount INT8U
4317  * @param protocolList Protocol []
4318  * @param protocolListLen int
4319  */
4320 #define emberAfFillCommandTunnelingClusterReadyDataClientToServer(tunnelId, protocolListComplete, numberOfOctetsLeft,              \
4321                                                                   protocolCount, protocolList, protocolListLen)                    \
4322     emberAfFillExternalBuffer(mask,                                                                                                \
4323                                                                                                                                    \
4324                               ZCL_READY_DATA_CLIENT_TO_SERVER_COMMAND_ID, "uuuub", tunnelId, protocolListComplete,                 \
4325                               numberOfOctetsLeft, protocolCount, protocolList, protocolListLen);
4326
4327 /** @brief Command description for GetSupportedTunnelProtocols
4328  *
4329  * Command: GetSupportedTunnelProtocols
4330  * @param protocolOffset INT8U
4331  * @param tunnelId INT16U
4332  */
4333 #define emberAfFillCommandTunnelingClusterGetSupportedTunnelProtocols(protocolOffset, tunnelId)                                    \
4334     emberAfFillExternalBuffer(mask,                                                                                                \
4335                                                                                                                                    \
4336                               ZCL_GET_SUPPORTED_TUNNEL_PROTOCOLS_COMMAND_ID, "uu", protocolOffset, tunnelId);
4337
4338 /** @brief Command description for SelectAvailableEmergencyCredit
4339  *
4340  * Command: SelectAvailableEmergencyCredit
4341  * @param commandIssueDateTime UTC_TIME
4342  * @param originatingDevice OriginatingDevice
4343  */
4344 #define emberAfFillCommandPrepaymentClusterSelectAvailableEmergencyCredit(commandIssueDateTime, originatingDevice)                 \
4345     emberAfFillExternalBuffer(mask,                                                                                                \
4346                                                                                                                                    \
4347                               ZCL_SELECT_AVAILABLE_EMERGENCY_CREDIT_COMMAND_ID, "uu", commandIssueDateTime, originatingDevice);
4348
4349 /** @brief Command description for PublishPrepaySnapshot
4350  *
4351  * Command: PublishPrepaySnapshot
4352  * @param snapshotId INT32U
4353  * @param snapshotTime UTC_TIME
4354  * @param totalSnapshotsFound INT8U
4355  * @param commandIndex INT8U
4356  * @param totalNumberOfCommands INT8U
4357  * @param snapshotCause PrepaySnapshotPayloadCause
4358  * @param snapshotPayloadType PrepaySnapshotPayloadType
4359  * @param snapshotPayload INT8U []
4360  * @param snapshotPayloadLen int
4361  */
4362 #define emberAfFillCommandPrepaymentClusterPublishPrepaySnapshot(snapshotId, snapshotTime, totalSnapshotsFound, commandIndex,      \
4363                                                                  totalNumberOfCommands, snapshotCause, snapshotPayloadType,        \
4364                                                                  snapshotPayload, snapshotPayloadLen)                              \
4365     emberAfFillExternalBuffer(mask,                                                                                                \
4366                                                                                                                                    \
4367                               ZCL_PUBLISH_PREPAY_SNAPSHOT_COMMAND_ID, "uuuuuuub", snapshotId, snapshotTime, totalSnapshotsFound,   \
4368                               commandIndex, totalNumberOfCommands, snapshotCause, snapshotPayloadType, snapshotPayload,            \
4369                               snapshotPayloadLen);
4370
4371 /** @brief Command description for ChangeDebt
4372  *
4373  * Command: ChangeDebt
4374  * @param issuerEventId INT32U
4375  * @param friendlyCredit FriendlyCredit
4376  * @param debtLabel OCTET_STRING
4377  * @param friendlyCreditCalendarId INT32U
4378  * @param debtAmount INT32U
4379  * @param emergencyCreditLimit INT32U
4380  * @param debtRecoveryMethod DebtRecoveryMethod
4381  * @param emergencyCreditThreshold INT32U
4382  * @param debtAmountType DebtAmountType
4383  * @param debtRecoveryStartTime UTC_TIME
4384  * @param debtRecoveryCollectionTime INT16U
4385  * @param debtRecoveryFrequency DebtRecoveryFrequency
4386  * @param debtRecoveryAmount INT32U
4387  * @param debtRecoveryBalancePercentage INT16U
4388  */
4389 #define emberAfFillCommandPrepaymentClusterChangeDebt(                                                                             \
4390     issuerEventId, friendlyCredit, debtLabel, friendlyCreditCalendarId, debtAmount, emergencyCreditLimit, debtRecoveryMethod,      \
4391     emergencyCreditThreshold, debtAmountType, debtRecoveryStartTime, debtRecoveryCollectionTime, debtRecoveryFrequency,            \
4392     debtRecoveryAmount, debtRecoveryBalancePercentage)                                                                             \
4393     emberAfFillExternalBuffer(mask,                                                                                                \
4394                                                                                                                                    \
4395                               ZCL_CHANGE_DEBT_COMMAND_ID, "uuuuuuuuuuuuuu", issuerEventId, friendlyCredit, debtLabel,              \
4396                               friendlyCreditCalendarId, debtAmount, emergencyCreditLimit, debtRecoveryMethod,                      \
4397                               emergencyCreditThreshold, debtAmountType, debtRecoveryStartTime, debtRecoveryCollectionTime,         \
4398                               debtRecoveryFrequency, debtRecoveryAmount, debtRecoveryBalancePercentage);
4399
4400 /** @brief Command description for EmergencyCreditSetup
4401  *
4402  * Command: EmergencyCreditSetup
4403  * @param issuerEventId INT32U
4404  * @param resultType ResultType
4405  * @param startTime UTC_TIME
4406  * @param topUpValue INT32U
4407  * @param emergencyCreditLimit INT32U
4408  * @param sourceOfTopUp OriginatingDevice
4409  * @param emergencyCreditThreshold INT32U
4410  * @param creditRemaining INT32U
4411  */
4412 #define emberAfFillCommandPrepaymentClusterEmergencyCreditSetup(issuerEventId, resultType, startTime, topUpValue,                  \
4413                                                                 emergencyCreditLimit, sourceOfTopUp, emergencyCreditThreshold,     \
4414                                                                 creditRemaining)                                                   \
4415     emberAfFillExternalBuffer(mask,                                                                                                \
4416                                                                                                                                    \
4417                               ZCL_EMERGENCY_CREDIT_SETUP_COMMAND_ID, "uuuuuuuu", issuerEventId, resultType, startTime, topUpValue, \
4418                               emergencyCreditLimit, sourceOfTopUp, emergencyCreditThreshold, creditRemaining);
4419
4420 /** @brief Command description for ConsumerTopUp
4421  *
4422  * Command: ConsumerTopUp
4423  * @param originatingDevice OriginatingDevice
4424  * @param topUpCode OCTET_STRING
4425  */
4426 #define emberAfFillCommandPrepaymentClusterConsumerTopUp(originatingDevice, topUpCode)                                             \
4427     emberAfFillExternalBuffer(mask,                                                                                                \
4428                                                                                                                                    \
4429                               ZCL_CONSUMER_TOP_UP_COMMAND_ID, "uu", originatingDevice, topUpCode);
4430
4431 /** @brief Command description for CreditAdjustment
4432  *
4433  * Command: CreditAdjustment
4434  * @param issuerEventId INT32U
4435  * @param commandIndex INT8U
4436  * @param startTime UTC_TIME
4437  * @param totalNumberOfCommands INT8U
4438  * @param creditAdjustmentType CreditAdjustmentType
4439  * @param topUpPayload TopUpPayload []
4440  * @param topUpPayloadLen int
4441  * @param creditAdjustmentValue INT32U
4442  */
4443 #define emberAfFillCommandPrepaymentClusterCreditAdjustment(issuerEventId, commandIndex, startTime, totalNumberOfCommands,         \
4444                                                             creditAdjustmentType, topUpPayload, topUpPayloadLen,                   \
4445                                                             creditAdjustmentValue)                                                 \
4446     emberAfFillExternalBuffer(mask,                                                                                                \
4447                                                                                                                                    \
4448                               ZCL_CREDIT_ADJUSTMENT_COMMAND_ID, "uuuuubu", issuerEventId, commandIndex, startTime,                 \
4449                               totalNumberOfCommands, creditAdjustmentType, topUpPayload, topUpPayloadLen, creditAdjustmentValue);
4450
4451 /** @brief Command description for ChangePaymentMode
4452  *
4453  * Command: ChangePaymentMode
4454  * @param providerId INT32U
4455  * @param commandIndex INT8U
4456  * @param issuerEventId INT32U
4457  * @param totalNumberOfCommands INT8U
4458  * @param implementationDateTime UTC_TIME
4459  * @param debtPayload DebtPayload []
4460  * @param debtPayloadLen int
4461  * @param proposedPaymentControlConfiguration PaymentControlConfiguration
4462  * @param cutOffValue INT32U
4463  */
4464 #define emberAfFillCommandPrepaymentClusterChangePaymentMode(providerId, commandIndex, issuerEventId, totalNumberOfCommands,       \
4465                                                              implementationDateTime, debtPayload, debtPayloadLen,                  \
4466                                                              proposedPaymentControlConfiguration, cutOffValue)                     \
4467     emberAfFillExternalBuffer(mask,                                                                                                \
4468                                                                                                                                    \
4469                               ZCL_CHANGE_PAYMENT_MODE_COMMAND_ID, "uuuuubuu", providerId, commandIndex, issuerEventId,             \
4470                               totalNumberOfCommands, implementationDateTime, debtPayload, debtPayloadLen,                          \
4471                               proposedPaymentControlConfiguration, cutOffValue);
4472
4473 /** @brief Command description for GetPrepaySnapshot
4474  *
4475  * Command: GetPrepaySnapshot
4476  * @param earliestStartTime UTC_TIME
4477  * @param latestEndTime UTC_TIME
4478  * @param snapshotOffset INT8U
4479  * @param snapshotCause PrepaySnapshotPayloadCause
4480  */
4481 #define emberAfFillCommandPrepaymentClusterGetPrepaySnapshot(earliestStartTime, latestEndTime, snapshotOffset, snapshotCause)      \
4482     emberAfFillExternalBuffer(mask,                                                                                                \
4483                                                                                                                                    \
4484                               ZCL_GET_PREPAY_SNAPSHOT_COMMAND_ID, "uuuu", earliestStartTime, latestEndTime, snapshotOffset,        \
4485                               snapshotCause);
4486
4487 /** @brief Command description for GetTopUpLog
4488  *
4489  * Command: GetTopUpLog
4490  * @param latestEndTime UTC_TIME
4491  * @param numberOfRecords INT8U
4492  */
4493 #define emberAfFillCommandPrepaymentClusterGetTopUpLog(latestEndTime, numberOfRecords)                                             \
4494     emberAfFillExternalBuffer(mask,                                                                                                \
4495                                                                                                                                    \
4496                               ZCL_GET_TOP_UP_LOG_COMMAND_ID, "uu", latestEndTime, numberOfRecords);
4497
4498 /** @brief Command description for SetLowCreditWarningLevel
4499  *
4500  * Command: SetLowCreditWarningLevel
4501  * @param lowCreditWarningLevel INT32U
4502  */
4503 #define emberAfFillCommandPrepaymentClusterSetLowCreditWarningLevel(lowCreditWarningLevel)                                         \
4504     emberAfFillExternalBuffer(mask,                                                                                                \
4505                                                                                                                                    \
4506                               ZCL_SET_LOW_CREDIT_WARNING_LEVEL_COMMAND_ID, "u", lowCreditWarningLevel);
4507
4508 /** @brief Command description for GetDebtRepaymentLog
4509  *
4510  * Command: GetDebtRepaymentLog
4511  * @param latestEndTime UTC_TIME
4512  * @param numberOfDebts INT8U
4513  * @param debtType RepaymentDebtType
4514  */
4515 #define emberAfFillCommandPrepaymentClusterGetDebtRepaymentLog(latestEndTime, numberOfDebts, debtType)                             \
4516     emberAfFillExternalBuffer(mask,                                                                                                \
4517                                                                                                                                    \
4518                               ZCL_GET_DEBT_REPAYMENT_LOG_COMMAND_ID, "uuu", latestEndTime, numberOfDebts, debtType);
4519
4520 /** @brief Command description for SetMaximumCreditLimit
4521  *
4522  * Command: SetMaximumCreditLimit
4523  * @param providerId INT32U
4524  * @param issuerEventId INT32U
4525  * @param implementationDateTime UTC_TIME
4526  * @param maximumCreditLevel INT32U
4527  * @param maximumCreditPerTopUp INT32U
4528  */
4529 #define emberAfFillCommandPrepaymentClusterSetMaximumCreditLimit(providerId, issuerEventId, implementationDateTime,                \
4530                                                                  maximumCreditLevel, maximumCreditPerTopUp)                        \
4531     emberAfFillExternalBuffer(mask,                                                                                                \
4532                                                                                                                                    \
4533                               ZCL_SET_MAXIMUM_CREDIT_LIMIT_COMMAND_ID, "uuuuu", providerId, issuerEventId, implementationDateTime, \
4534                               maximumCreditLevel, maximumCreditPerTopUp);
4535
4536 /** @brief Command description for SetOverallDebtCap
4537  *
4538  * Command: SetOverallDebtCap
4539  * @param providerId INT32U
4540  * @param issuerEventId INT32U
4541  * @param implementationDateTime UTC_TIME
4542  * @param overallDebtCap INT32U
4543  */
4544 #define emberAfFillCommandPrepaymentClusterSetOverallDebtCap(providerId, issuerEventId, implementationDateTime, overallDebtCap)    \
4545     emberAfFillExternalBuffer(mask,                                                                                                \
4546                                                                                                                                    \
4547                               ZCL_SET_OVERALL_DEBT_CAP_COMMAND_ID, "uuuu", providerId, issuerEventId, implementationDateTime,      \
4548                               overallDebtCap);
4549
4550 /** @brief Command description for ReportEventStatus
4551  *
4552  * Command: ReportEventStatus
4553  * @param issuerEventId INT32U
4554  * @param issuerEventId INT32U
4555  * @param eventStatus AmiEventStatus
4556  * @param deviceClass AmiDeviceClass
4557  * @param eventStatusTime UTC_TIME
4558  * @param utilityEnrollmentGroup INT8U
4559  * @param criticalityLevelApplied AmiCriticalityLevel
4560  * @param actionRequired INT8U
4561  * @param coolingTemperatureSetPointApplied INT16U
4562  * @param heatingTemperatureSetPointApplied INT16U
4563  * @param averageLoadAdjustmentPercentageApplied INT8S
4564  * @param dutyCycleApplied INT8U
4565  * @param eventControl AmiEventControl
4566  */
4567 #define emberAfFillCommandEnergy                                                                                                   \
4568     ManagementClusterReportEventStatus(issuerEventId, issuerEventId, eventStatus, deviceClass, eventStatusTime,                    \
4569                                        utilityEnrollmentGroup, criticalityLevelApplied, actionRequired,                            \
4570                                        coolingTemperatureSetPointApplied, heatingTemperatureSetPointApplied,                       \
4571                                        averageLoadAdjustmentPercentageApplied, dutyCycleApplied, eventControl)                     \
4572         emberAfFillExternalBuffer(mask,                                                                                            \
4573                                                                                                                                    \
4574                                   ZCL_REPORT_EVENT_STATUS_COMMAND_ID, "uuuuuuuuuuuuu", issuerEventId, issuerEventId, eventStatus,  \
4575                                   deviceClass, eventStatusTime, utilityEnrollmentGroup, criticalityLevelApplied, actionRequired,   \
4576                                   coolingTemperatureSetPointApplied, heatingTemperatureSetPointApplied,                            \
4577                                   averageLoadAdjustmentPercentageApplied, dutyCycleApplied, eventControl);
4578
4579 /** @brief Command description for PublishCalendar
4580  *
4581  * Command: PublishCalendar
4582  * @param providerId INT32U
4583  * @param earliestStartTime UTC_TIME
4584  * @param issuerEventId INT32U
4585  * @param minIssuerEventId INT32U
4586  * @param issuerCalendarId INT32U
4587  * @param numberOfCalendars INT8U
4588  * @param startTime UTC_TIME
4589  * @param calendarType CalendarType
4590  * @param calendarType CalendarType
4591  * @param providerId INT32U
4592  * @param calendarTimeReference CalendarTimeReference
4593  * @param calendarName OCTET_STRING
4594  * @param numberOfSeasons INT8U
4595  * @param numberOfWeekProfiles INT8U
4596  * @param numberOfDayProfiles INT8U
4597  */
4598 #define emberAfFillCommandCalendarClusterPublishCalendar(                                                                          \
4599     providerId, earliestStartTime, issuerEventId, minIssuerEventId, issuerCalendarId, numberOfCalendars, startTime, calendarType,  \
4600     calendarType, providerId, calendarTimeReference, calendarName, numberOfSeasons, numberOfWeekProfiles, numberOfDayProfiles)     \
4601     emberAfFillExternalBuffer(mask,                                                                                                \
4602                                                                                                                                    \
4603                               ZCL_PUBLISH_CALENDAR_COMMAND_ID, "uuuuuuuuuuuuuuu", providerId, earliestStartTime, issuerEventId,    \
4604                               minIssuerEventId, issuerCalendarId, numberOfCalendars, startTime, calendarType, calendarType,        \
4605                               providerId, calendarTimeReference, calendarName, numberOfSeasons, numberOfWeekProfiles,              \
4606                               numberOfDayProfiles);
4607
4608 /** @brief Command description for PublishDayProfile
4609  *
4610  * Command: PublishDayProfile
4611  * @param providerId INT32U
4612  * @param providerId INT32U
4613  * @param issuerEventId INT32U
4614  * @param issuerCalendarId INT32U
4615  * @param issuerCalendarId INT32U
4616  * @param startDayId INT8U
4617  * @param dayId INT8U
4618  * @param numberOfDays INT8U
4619  * @param totalNumberOfScheduleEntries INT8U
4620  * @param commandIndex INT8U
4621  * @param totalNumberOfCommands INT8U
4622  * @param calendarType CalendarType
4623  * @param dayScheduleEntries ScheduleEntry []
4624  * @param dayScheduleEntriesLen int
4625  */
4626 #define emberAfFillCommandCalendarClusterPublishDayProfile(                                                                        \
4627     providerId, providerId, issuerEventId, issuerCalendarId, issuerCalendarId, startDayId, dayId, numberOfDays,                    \
4628     totalNumberOfScheduleEntries, commandIndex, totalNumberOfCommands, calendarType, dayScheduleEntries, dayScheduleEntriesLen)    \
4629     emberAfFillExternalBuffer(mask,                                                                                                \
4630                                                                                                                                    \
4631                               ZCL_PUBLISH_DAY_PROFILE_COMMAND_ID, "uuuuuuuuuuuub", providerId, providerId, issuerEventId,          \
4632                               issuerCalendarId, issuerCalendarId, startDayId, dayId, numberOfDays, totalNumberOfScheduleEntries,   \
4633                               commandIndex, totalNumberOfCommands, calendarType, dayScheduleEntries, dayScheduleEntriesLen);
4634
4635 /** @brief Command description for PublishWeekProfile
4636  *
4637  * Command: PublishWeekProfile
4638  * @param providerId INT32U
4639  * @param providerId INT32U
4640  * @param issuerEventId INT32U
4641  * @param issuerCalendarId INT32U
4642  * @param issuerCalendarId INT32U
4643  * @param startWeekId INT8U
4644  * @param weekId INT8U
4645  * @param numberOfWeeks INT8U
4646  * @param dayIdRefMonday INT8U
4647  * @param dayIdRefTuesday INT8U
4648  * @param dayIdRefWednesday INT8U
4649  * @param dayIdRefThursday INT8U
4650  * @param dayIdRefFriday INT8U
4651  * @param dayIdRefSaturday INT8U
4652  * @param dayIdRefSunday INT8U
4653  */
4654 #define emberAfFillCommandCalendarClusterPublishWeekProfile(                                                                       \
4655     providerId, providerId, issuerEventId, issuerCalendarId, issuerCalendarId, startWeekId, weekId, numberOfWeeks, dayIdRefMonday, \
4656     dayIdRefTuesday, dayIdRefWednesday, dayIdRefThursday, dayIdRefFriday, dayIdRefSaturday, dayIdRefSunday)                        \
4657     emberAfFillExternalBuffer(mask,                                                                                                \
4658                                                                                                                                    \
4659                               ZCL_PUBLISH_WEEK_PROFILE_COMMAND_ID, "uuuuuuuuuuuuuuu", providerId, providerId, issuerEventId,       \
4660                               issuerCalendarId, issuerCalendarId, startWeekId, weekId, numberOfWeeks, dayIdRefMonday,              \
4661                               dayIdRefTuesday, dayIdRefWednesday, dayIdRefThursday, dayIdRefFriday, dayIdRefSaturday,              \
4662                               dayIdRefSunday);
4663
4664 /** @brief Command description for PublishSeasons
4665  *
4666  * Command: PublishSeasons
4667  * @param providerId INT32U
4668  * @param providerId INT32U
4669  * @param issuerEventId INT32U
4670  * @param issuerCalendarId INT32U
4671  * @param issuerCalendarId INT32U
4672  * @param commandIndex INT8U
4673  * @param totalNumberOfCommands INT8U
4674  * @param seasonEntries SeasonEntry []
4675  * @param seasonEntriesLen int
4676  */
4677 #define emberAfFillCommandCalendarClusterPublishSeasons(providerId, providerId, issuerEventId, issuerCalendarId, issuerCalendarId, \
4678                                                         commandIndex, totalNumberOfCommands, seasonEntries, seasonEntriesLen)      \
4679     emberAfFillExternalBuffer(mask,                                                                                                \
4680                                                                                                                                    \
4681                               ZCL_PUBLISH_SEASONS_COMMAND_ID, "uuuuuuub", providerId, providerId, issuerEventId, issuerCalendarId, \
4682                               issuerCalendarId, commandIndex, totalNumberOfCommands, seasonEntries, seasonEntriesLen);
4683
4684 /** @brief Command description for PublishSpecialDays
4685  *
4686  * Command: PublishSpecialDays
4687  * @param providerId INT32U
4688  * @param startTime UTC_TIME
4689  * @param issuerEventId INT32U
4690  * @param numberOfEvents INT8U
4691  * @param issuerCalendarId INT32U
4692  * @param calendarType CalendarType
4693  * @param startTime UTC_TIME
4694  * @param providerId INT32U
4695  * @param calendarType CalendarType
4696  * @param issuerCalendarId INT32U
4697  * @param totalNumberOfSpecialDays INT8U
4698  * @param commandIndex INT8U
4699  * @param totalNumberOfCommands INT8U
4700  * @param specialDayEntries SpecialDay []
4701  * @param specialDayEntriesLen int
4702  */
4703 #define emberAfFillCommandCalendarClusterPublishSpecialDays(                                                                       \
4704     providerId, startTime, issuerEventId, numberOfEvents, issuerCalendarId, calendarType, startTime, providerId, calendarType,     \
4705     issuerCalendarId, totalNumberOfSpecialDays, commandIndex, totalNumberOfCommands, specialDayEntries, specialDayEntriesLen)      \
4706     emberAfFillExternalBuffer(mask,                                                                                                \
4707                                                                                                                                    \
4708                               ZCL_PUBLISH_SPECIAL_DAYS_COMMAND_ID, "uuuuuuuuuuuuub", providerId, startTime, issuerEventId,         \
4709                               numberOfEvents, issuerCalendarId, calendarType, startTime, providerId, calendarType,                 \
4710                               issuerCalendarId, totalNumberOfSpecialDays, commandIndex, totalNumberOfCommands, specialDayEntries,  \
4711                               specialDayEntriesLen);
4712
4713 /** @brief Command description for GetCalendarCancellation
4714  *
4715  * Command: GetCalendarCancellation
4716  * @param providerId INT32U
4717  * @param issuerCalendarId INT32U
4718  * @param calendarType CalendarType
4719  */
4720 #define emberAfFillCommandCalendarClusterGetCalendarCancellation(providerId, issuerCalendarId, calendarType)                       \
4721     emberAfFillExternalBuffer(mask,                                                                                                \
4722                                                                                                                                    \
4723                               ZCL_GET_CALENDAR_CANCELLATION_COMMAND_ID, "uuu", providerId, issuerCalendarId, calendarType);
4724
4725 /** @brief Command description for GetChangeOfTenancy
4726  *
4727  * Command: GetChangeOfTenancy
4728  * @param providerId INT32U
4729  * @param issuerEventId INT32U
4730  * @param tariffType TariffType
4731  * @param implementationDateTime UTC_TIME
4732  * @param proposedTenancyChangeControl ProposedChangeControl
4733  */
4734 #define emberAfFillCommandDevice                                                                                                   \
4735     ManagementClusterGetChangeOfTenancy(providerId, issuerEventId, tariffType, implementationDateTime,                             \
4736                                         proposedTenancyChangeControl)                                                              \
4737         emberAfFillExternalBuffer(mask,                                                                                            \
4738                                                                                                                                    \
4739                                   ZCL_GET_CHANGE_OF_TENANCY_COMMAND_ID, "uuuuu", providerId, issuerEventId, tariffType,            \
4740                                   implementationDateTime, proposedTenancyChangeControl);
4741
4742 /** @brief Command description for GetChangeOfSupplier
4743  *
4744  * Command: GetChangeOfSupplier
4745  * @param currentProviderId INT32U
4746  * @param issuerEventId INT32U
4747  * @param tariffType TariffType
4748  * @param proposedProviderId INT32U
4749  * @param providerChangeImplementationTime UTC_TIME
4750  * @param providerChangeControl ProposedChangeControl
4751  * @param proposedProviderName OCTET_STRING
4752  * @param proposedProviderContactDetails OCTET_STRING
4753  */
4754 #define emberAfFillCommandDevice                                                                                                   \
4755     ManagementClusterGetChangeOfSupplier(currentProviderId, issuerEventId, tariffType, proposedProviderId,                         \
4756                                          providerChangeImplementationTime, providerChangeControl, proposedProviderName,            \
4757                                          proposedProviderContactDetails)                                                           \
4758         emberAfFillExternalBuffer(mask,                                                                                            \
4759                                                                                                                                    \
4760                                   ZCL_GET_CHANGE_OF_SUPPLIER_COMMAND_ID, "uuuuuuuu", currentProviderId, issuerEventId, tariffType, \
4761                                   proposedProviderId, providerChangeImplementationTime, providerChangeControl,                     \
4762                                   proposedProviderName, proposedProviderContactDetails);
4763
4764 /** @brief Command description for RequestNewPassword
4765  *
4766  * Command: RequestNewPassword
4767  * @param passwordType PasswordType
4768  * @param issuerEventId INT32U
4769  * @param implementationDateTime UTC_TIME
4770  * @param durationInMinutes INT16U
4771  * @param passwordType PasswordType
4772  * @param password OCTET_STRING
4773  */
4774 #define emberAfFillCommandDevice                                                                                                   \
4775     ManagementClusterRequestNewPassword(passwordType, issuerEventId, implementationDateTime, durationInMinutes, passwordType,      \
4776                                         password)                                                                                  \
4777         emberAfFillExternalBuffer(mask,                                                                                            \
4778                                                                                                                                    \
4779                                   ZCL_REQUEST_NEW_PASSWORD_COMMAND_ID, "uuuuuu", passwordType, issuerEventId,                      \
4780                                   implementationDateTime, durationInMinutes, passwordType, password);
4781
4782 /** @brief Command description for GetSiteId
4783  *
4784  * Command: GetSiteId
4785  * @param issuerEventId INT32U
4786  * @param siteIdTime UTC_TIME
4787  * @param providerId INT32U
4788  * @param siteId OCTET_STRING
4789  */
4790 #define emberAfFillCommandDevice                                                                                                   \
4791     ManagementClusterGetSiteId(issuerEventId, siteIdTime, providerId, siteId)                                                      \
4792         emberAfFillExternalBuffer(mask,                                                                                            \
4793                                                                                                                                    \
4794                                   ZCL_GET_SITE_ID_COMMAND_ID, "uuuu", issuerEventId, siteIdTime, providerId, siteId);
4795
4796 /** @brief Command description for ReportEventConfiguration
4797  *
4798  * Command: ReportEventConfiguration
4799  * @param commandIndex INT8U
4800  * @param issuerEventId INT32U
4801  * @param totalCommands INT8U
4802  * @param startDateTime UTC_TIME
4803  * @param eventConfigurationPayload EventConfigurationPayload []
4804  * @param eventConfigurationPayloadLen int
4805  * @param eventConfiguration EventConfiguration
4806  * @param configurationControl EventConfigurationControl
4807  * @param eventConfigurationPayload INT8U []
4808  * @param eventConfigurationPayloadLen int
4809  */
4810 #define emberAfFillCommandDevice                                                                                                   \
4811     ManagementClusterReportEventConfiguration(commandIndex, issuerEventId, totalCommands, startDateTime,                           \
4812                                               eventConfigurationPayload, eventConfigurationPayloadLen, eventConfiguration,         \
4813                                               configurationControl, eventConfigurationPayload, eventConfigurationPayloadLen)       \
4814         emberAfFillExternalBuffer(mask,                                                                                            \
4815                                                                                                                                    \
4816                                   ZCL_REPORT_EVENT_CONFIGURATION_COMMAND_ID, "uuuubuub", commandIndex, issuerEventId,              \
4817                                   totalCommands, startDateTime, eventConfigurationPayload, eventConfigurationPayloadLen,           \
4818                                   eventConfiguration, configurationControl, eventConfigurationPayload,                             \
4819                                   eventConfigurationPayloadLen);
4820
4821 /** @brief Command description for GetCIN
4822  *
4823  * Command: GetCIN
4824  * @param eventId INT16U
4825  */
4826 #define emberAfFillCommandDevice                                                                                                   \
4827     ManagementClusterGetCIN(eventId) emberAfFillExternalBuffer(mask,                                                               \
4828                                                                                                                                    \
4829                                                                ZCL_GET_CIN_COMMAND_ID, "u", eventId);
4830
4831 /** @brief Command description for UpdateCIN
4832  *
4833  * Command: UpdateCIN
4834  * @param issuerEventId INT32U
4835  * @param implementationTime UTC_TIME
4836  * @param providerId INT32U
4837  * @param customerIdNumber OCTET_STRING
4838  */
4839 #define emberAfFillCommandDevice                                                                                                   \
4840     ManagementClusterUpdateCIN(issuerEventId, implementationTime, providerId, customerIdNumber) emberAfFillExternalBuffer(         \
4841         mask,                                                                                                                      \
4842                                                                                                                                    \
4843         ZCL_UPDATE_CIN_COMMAND_ID, "uuuu", issuerEventId, implementationTime, providerId, customerIdNumber);
4844
4845 /** @brief Command description for GetEventLog
4846  *
4847  * Command: GetEventLog
4848  * @param eventControlLogId EventControlLogId
4849  * @param logId EventLogId
4850  * @param eventId INT16U
4851  * @param eventId INT16U
4852  * @param startTime UTC_TIME
4853  * @param eventTime UTC_TIME
4854  * @param endTime UTC_TIME
4855  * @param eventControl EventActionControl
4856  * @param numberOfEvents INT8U
4857  * @param eventData OCTET_STRING
4858  * @param eventOffset INT16U
4859  */
4860 #define emberAfFillCommandEventsClusterGetEventLog(eventControlLogId, logId, eventId, eventId, startTime, eventTime, endTime,      \
4861                                                    eventControl, numberOfEvents, eventData, eventOffset)                           \
4862     emberAfFillExternalBuffer(mask,                                                                                                \
4863                                                                                                                                    \
4864                               ZCL_GET_EVENT_LOG_COMMAND_ID, "uuuuuuuuuuu", eventControlLogId, logId, eventId, eventId, startTime,  \
4865                               eventTime, endTime, eventControl, numberOfEvents, eventData, eventOffset);
4866
4867 /** @brief Command description for ClearEventLogRequest
4868  *
4869  * Command: ClearEventLogRequest
4870  * @param logId EventLogId
4871  * @param totalNumberOfEvents INT16U
4872  * @param commandIndex INT8U
4873  * @param totalCommands INT8U
4874  * @param logPayloadControl NumberOfEventsLogPayloadControl
4875  * @param logPayload EventLogPayload []
4876  * @param logPayloadLen int
4877  */
4878 #define emberAfFillCommandEventsClusterClearEventLogRequest(logId, totalNumberOfEvents, commandIndex, totalCommands,               \
4879                                                             logPayloadControl, logPayload, logPayloadLen)                          \
4880     emberAfFillExternalBuffer(mask,                                                                                                \
4881                                                                                                                                    \
4882                               ZCL_CLEAR_EVENT_LOG_REQUEST_COMMAND_ID, "uuuuub", logId, totalNumberOfEvents, commandIndex,          \
4883                               totalCommands, logPayloadControl, logPayload, logPayloadLen);
4884
4885 /** @brief Command description for ClearEventLogResponse
4886  *
4887  * Command: ClearEventLogResponse
4888  * @param clearedEventsLogs ClearedEventsLogs
4889  */
4890 #define emberAfFillCommandEventsClusterClearEventLogResponse(clearedEventsLogs)                                                    \
4891     emberAfFillExternalBuffer(mask,                                                                                                \
4892                                                                                                                                    \
4893                               ZCL_CLEAR_EVENT_LOG_RESPONSE_COMMAND_ID, "u", clearedEventsLogs);
4894
4895 /** @brief Command description for PairingResponse
4896  *
4897  * Command: PairingResponse
4898  * @param pairingInformationVersion INT32U
4899  * @param localPairingInformationVersion INT32U
4900  * @param totalNumberOfDevices INT8U
4901  * @param eui64OfRequestingDevice IEEE_ADDRESS
4902  * @param commandIndex INT8U
4903  * @param totalNumberOfCommands INT8U
4904  * @param eui64s IEEE_ADDRESS []
4905  * @param eui64sLen int
4906  */
4907 #define emberAfFillCommandMDU                                                                                                      \
4908     PairingClusterPairingResponse(pairingInformationVersion, localPairingInformationVersion, totalNumberOfDevices,                 \
4909                                   eui64OfRequestingDevice, commandIndex, totalNumberOfCommands, eui64s, eui64sLen)                 \
4910         emberAfFillExternalBuffer(mask,                                                                                            \
4911                                                                                                                                    \
4912                                   ZCL_PAIRING_RESPONSE_COMMAND_ID, "uuuuuub", pairingInformationVersion,                           \
4913                                   localPairingInformationVersion, totalNumberOfDevices, eui64OfRequestingDevice, commandIndex,     \
4914                                   totalNumberOfCommands, eui64s, eui64sLen);
4915
4916 /** @brief Command description for GetSuspendZclMessagesStatus
4917  *
4918  * Command: GetSuspendZclMessagesStatus
4919  * @param period INT8U
4920  */
4921 #define emberAfFillCommandSub                                                                                                      \
4922     -GHzClusterGetSuspendZclMessagesStatus(period)                                                                                 \
4923         emberAfFillExternalBuffer(mask,                                                                                            \
4924                                                                                                                                    \
4925                                   ZCL_GET_SUSPEND_ZCL_MESSAGES_STATUS_COMMAND_ID, "u", period);
4926
4927 /** @brief Command description for InitiateKeyEstablishmentRequest
4928  *
4929  * Command: InitiateKeyEstablishmentRequest
4930  * @param keyEstablishmentSuite BITMAP16
4931  * @param requestedKeyEstablishmentSuite BITMAP16
4932  * @param ephemeralDataGenerateTime INT8U
4933  * @param ephemeralDataGenerateTime INT8U
4934  * @param confirmKeyGenerateTime INT8U
4935  * @param confirmKeyGenerateTime INT8U
4936  * @param identity Identity
4937  * @param identity Identity
4938  */
4939 #define emberAfFillCommandKey                                                                                                      \
4940     EstablishmentClusterInitiateKeyEstablishmentRequest(keyEstablishmentSuite, requestedKeyEstablishmentSuite,                     \
4941                                                         ephemeralDataGenerateTime, ephemeralDataGenerateTime,                      \
4942                                                         confirmKeyGenerateTime, confirmKeyGenerateTime, identity, identity)        \
4943         emberAfFillExternalBuffer(mask,                                                                                            \
4944                                                                                                                                    \
4945                                   ZCL_INITIATE_KEY_ESTABLISHMENT_REQUEST_COMMAND_ID, "uuuuuuuu", keyEstablishmentSuite,            \
4946                                   requestedKeyEstablishmentSuite, ephemeralDataGenerateTime, ephemeralDataGenerateTime,            \
4947                                   confirmKeyGenerateTime, confirmKeyGenerateTime, identity, identity);
4948
4949 /** @brief Command description for EphemeralDataRequest
4950  *
4951  * Command: EphemeralDataRequest
4952  * @param ephemeralData EphemeralData
4953  * @param ephemeralData EphemeralData
4954  */
4955 #define emberAfFillCommandKey                                                                                                      \
4956     EstablishmentClusterEphemeralDataRequest(ephemeralData, ephemeralData)                                                         \
4957         emberAfFillExternalBuffer(mask,                                                                                            \
4958                                                                                                                                    \
4959                                   ZCL_EPHEMERAL_DATA_REQUEST_COMMAND_ID, "uu", ephemeralData, ephemeralData);
4960
4961 /** @brief Command description for ConfirmKeyDataRequest
4962  *
4963  * Command: ConfirmKeyDataRequest
4964  * @param secureMessageAuthenticationCode Smac
4965  * @param secureMessageAuthenticationCode Smac
4966  */
4967 #define emberAfFillCommandKey                                                                                                      \
4968     EstablishmentClusterConfirmKeyDataRequest(secureMessageAuthenticationCode, secureMessageAuthenticationCode)                    \
4969         emberAfFillExternalBuffer(mask,                                                                                            \
4970                                                                                                                                    \
4971                                   ZCL_CONFIRM_KEY_DATA_REQUEST_COMMAND_ID, "uu", secureMessageAuthenticationCode,                  \
4972                                   secureMessageAuthenticationCode);
4973
4974 /** @brief Command description for TerminateKeyEstablishment
4975  *
4976  * Command: TerminateKeyEstablishment
4977  * @param statusCode AmiKeyEstablishmentStatus
4978  * @param waitTime INT8U
4979  * @param keyEstablishmentSuite BITMAP16
4980  */
4981 #define emberAfFillCommandKey                                                                                                      \
4982     EstablishmentClusterTerminateKeyEstablishment(statusCode, waitTime, keyEstablishmentSuite)                                     \
4983         emberAfFillExternalBuffer(mask,                                                                                            \
4984                                                                                                                                    \
4985                                   ZCL_TERMINATE_KEY_ESTABLISHMENT_COMMAND_ID, "uuu", statusCode, waitTime, keyEstablishmentSuite);
4986
4987 /** @brief Command description for RequestInformation
4988  *
4989  * Command: RequestInformation
4990  * @param inquiryId ENUM8
4991  * @param number INT8U
4992  * @param dataTypeId BITMAP8
4993  * @param buffer INT8U []
4994  * @param bufferLen int
4995  * @param requestInformationPayload INT8U []
4996  * @param requestInformationPayloadLen int
4997  */
4998 #define emberAfFillCommandInformationClusterRequestInformation(inquiryId, number, dataTypeId, buffer, bufferLen,                   \
4999                                                                requestInformationPayload, requestInformationPayloadLen)            \
5000     emberAfFillExternalBuffer(mask,                                                                                                \
5001                                                                                                                                    \
5002                               ZCL_REQUEST_INFORMATION_COMMAND_ID, "uuubb", inquiryId, number, dataTypeId, buffer, bufferLen,       \
5003                               requestInformationPayload, requestInformationPayloadLen);
5004
5005 /** @brief Command description for PushInformationResponse
5006  *
5007  * Command: PushInformationResponse
5008  * @param notificationList Notification []
5009  * @param notificationListLen int
5010  * @param contents INT8U []
5011  * @param contentsLen int
5012  */
5013 #define emberAfFillCommandInformationClusterPushInformationResponse(notificationList, notificationListLen, contents, contentsLen)  \
5014     emberAfFillExternalBuffer(mask,                                                                                                \
5015                                                                                                                                    \
5016                               ZCL_PUSH_INFORMATION_RESPONSE_COMMAND_ID, "bb", notificationList, notificationListLen, contents,     \
5017                               contentsLen);
5018
5019 /** @brief Command description for SendPreference
5020  *
5021  * Command: SendPreference
5022  * @param preferenceType INT16U
5023  * @param statusFeedbackList Status []
5024  * @param statusFeedbackListLen int
5025  * @param preferencePayload INT8U []
5026  * @param preferencePayloadLen int
5027  */
5028 #define emberAfFillCommandInformationClusterSendPreference(preferenceType, statusFeedbackList, statusFeedbackListLen,              \
5029                                                            preferencePayload, preferencePayloadLen)                                \
5030     emberAfFillExternalBuffer(mask,                                                                                                \
5031                                                                                                                                    \
5032                               ZCL_SEND_PREFERENCE_COMMAND_ID, "ubb", preferenceType, statusFeedbackList, statusFeedbackListLen,    \
5033                               preferencePayload, preferencePayloadLen);
5034
5035 /** @brief Command description for ServerRequestPreference
5036  *
5037  * Command: ServerRequestPreference
5038  * @param statusFeedback Status
5039  * @param preferenceType INT16U
5040  * @param preferencePayload INT8U []
5041  * @param preferencePayloadLen int
5042  */
5043 #define emberAfFillCommandInformationClusterServerRequestPreference(statusFeedback, preferenceType, preferencePayload,             \
5044                                                                     preferencePayloadLen)                                          \
5045     emberAfFillExternalBuffer(mask,                                                                                                \
5046                                                                                                                                    \
5047                               ZCL_SERVER_REQUEST_PREFERENCE_COMMAND_ID, "uub", statusFeedback, preferenceType, preferencePayload,  \
5048                               preferencePayloadLen);
5049
5050 /** @brief Command description for Update
5051  *
5052  * Command: Update
5053  * @param accessControl ENUM8
5054  * @param statusFeedbackList Status []
5055  * @param statusFeedbackListLen int
5056  * @param option BITMAP8
5057  * @param contents INT8U []
5058  * @param contentsLen int
5059  */
5060 #define emberAfFillCommandInformationClusterUpdate(accessControl, statusFeedbackList, statusFeedbackListLen, option, contents,     \
5061                                                    contentsLen)                                                                    \
5062     emberAfFillExternalBuffer(mask,                                                                                                \
5063                                                                                                                                    \
5064                               ZCL_UPDATE_COMMAND_ID, "ubub", accessControl, statusFeedbackList, statusFeedbackListLen, option,     \
5065                               contents, contentsLen);
5066
5067 /** @brief Command description for Delete
5068  *
5069  * Command: Delete
5070  * @param deletionOptions BITMAP8
5071  * @param notificationList Notification []
5072  * @param notificationListLen int
5073  * @param contentIds INT16U []
5074  * @param contentIdsLen int
5075  */
5076 #define emberAfFillCommandInformationClusterDelete(deletionOptions, notificationList, notificationListLen, contentIds,             \
5077                                                    contentIdsLen)                                                                  \
5078     emberAfFillExternalBuffer(mask,                                                                                                \
5079                                                                                                                                    \
5080                               ZCL_DELETE_COMMAND_ID, "ubb", deletionOptions, notificationList, notificationListLen, contentIds,    \
5081                               contentIdsLen);
5082
5083 /** @brief Command description for ConfigureNodeDescription
5084  *
5085  * Command: ConfigureNodeDescription
5086  * @param description CHAR_STRING
5087  * @param notificationList Notification []
5088  * @param notificationListLen int
5089  */
5090 #define emberAfFillCommandInformationClusterConfigureNodeDescription(description, notificationList, notificationListLen)           \
5091     emberAfFillExternalBuffer(mask,                                                                                                \
5092                                                                                                                                    \
5093                               ZCL_CONFIGURE_NODE_DESCRIPTION_COMMAND_ID, "ub", description, notificationList,                      \
5094                               notificationListLen);
5095
5096 /** @brief Command description for ConfigureDeliveryEnable
5097  *
5098  * Command: ConfigureDeliveryEnable
5099  * @param enable BOOLEAN
5100  */
5101 #define emberAfFillCommandInformationClusterConfigureDeliveryEnable(enable)                                                        \
5102     emberAfFillExternalBuffer(mask,                                                                                                \
5103                                                                                                                                    \
5104                               ZCL_CONFIGURE_DELIVERY_ENABLE_COMMAND_ID, "u", enable);
5105
5106 /** @brief Command description for ConfigurePushInformationTimer
5107  *
5108  * Command: ConfigurePushInformationTimer
5109  * @param timer INT32U
5110  */
5111 #define emberAfFillCommandInformationClusterConfigurePushInformationTimer(timer)                                                   \
5112     emberAfFillExternalBuffer(mask,                                                                                                \
5113                                                                                                                                    \
5114                               ZCL_CONFIGURE_PUSH_INFORMATION_TIMER_COMMAND_ID, "u", timer);
5115
5116 /** @brief Command description for ConfigureSetRootId
5117  *
5118  * Command: ConfigureSetRootId
5119  * @param rootId INT16U
5120  */
5121 #define emberAfFillCommandInformationClusterConfigureSetRootId(rootId)                                                             \
5122     emberAfFillExternalBuffer(mask,                                                                                                \
5123                                                                                                                                    \
5124                               ZCL_CONFIGURE_SET_ROOT_ID_COMMAND_ID, "u", rootId);
5125
5126 /** @brief Command description for ReadFileRequest
5127  *
5128  * Command: ReadFileRequest
5129  * @param fileIndex INT16U
5130  * @param writeOptions BITMAP8
5131  * @param fileStartPositionAndRequestedOctetCount INT8U []
5132  * @param fileStartPositionAndRequestedOctetCountLen int
5133  * @param fileSize INT8U []
5134  * @param fileSizeLen int
5135  */
5136 #define emberAfFillCommandData                                                                                                     \
5137     SharingClusterReadFileRequest(fileIndex, writeOptions, fileStartPositionAndRequestedOctetCount,                                \
5138                                   fileStartPositionAndRequestedOctetCountLen, fileSize, fileSizeLen)                               \
5139         emberAfFillExternalBuffer(mask,                                                                                            \
5140                                                                                                                                    \
5141                                   ZCL_READ_FILE_REQUEST_COMMAND_ID, "uubb", fileIndex, writeOptions,                               \
5142                                   fileStartPositionAndRequestedOctetCount, fileStartPositionAndRequestedOctetCountLen, fileSize,   \
5143                                   fileSizeLen);
5144
5145 /** @brief Command description for ReadRecordRequest
5146  *
5147  * Command: ReadRecordRequest
5148  * @param fileIndex INT16U
5149  * @param fileIndex INT16U
5150  * @param fileStartRecordAndRequestedRecordCount INT8U []
5151  * @param fileStartRecordAndRequestedRecordCountLen int
5152  * @param fileStartPosition INT32U
5153  * @param octetCount INT32U
5154  */
5155 #define emberAfFillCommandData                                                                                                     \
5156     SharingClusterReadRecordRequest(fileIndex, fileIndex, fileStartRecordAndRequestedRecordCount,                                  \
5157                                     fileStartRecordAndRequestedRecordCountLen, fileStartPosition, octetCount)                      \
5158         emberAfFillExternalBuffer(mask,                                                                                            \
5159                                                                                                                                    \
5160                                   ZCL_READ_RECORD_REQUEST_COMMAND_ID, "uubuu", fileIndex, fileIndex,                               \
5161                                   fileStartRecordAndRequestedRecordCount, fileStartRecordAndRequestedRecordCountLen,               \
5162                                   fileStartPosition, octetCount);
5163
5164 /** @brief Command description for WriteFileResponse
5165  *
5166  * Command: WriteFileResponse
5167  * @param status ENUM8
5168  * @param fileIndex INT16U
5169  * @param fileIndex INT8U []
5170  * @param fileIndexLen int
5171  * @param fileStartRecord INT16U
5172  * @param recordCount INT16U
5173  */
5174 #define emberAfFillCommandData                                                                                                     \
5175     SharingClusterWriteFileResponse(status, fileIndex, fileIndex, fileIndexLen, fileStartRecord, recordCount)                      \
5176         emberAfFillExternalBuffer(mask,                                                                                            \
5177                                                                                                                                    \
5178                                   ZCL_WRITE_FILE_RESPONSE_COMMAND_ID, "uubuu", status, fileIndex, fileIndex, fileIndexLen,         \
5179                                   fileStartRecord, recordCount);
5180
5181 /** @brief Command description for FileTransmission
5182  *
5183  * Command: FileTransmission
5184  * @param transmitOptions BITMAP8
5185  * @param buffer INT8U []
5186  * @param bufferLen int
5187  */
5188 #define emberAfFillCommandData                                                                                                     \
5189     SharingClusterFileTransmission(transmitOptions, buffer, bufferLen)                                                             \
5190         emberAfFillExternalBuffer(mask,                                                                                            \
5191                                                                                                                                    \
5192                                   ZCL_FILE_TRANSMISSION_COMMAND_ID, "ub", transmitOptions, buffer, bufferLen);
5193
5194 /** @brief Command description for RecordTransmission
5195  *
5196  * Command: RecordTransmission
5197  * @param transmitOptions BITMAP8
5198  * @param buffer INT8U []
5199  * @param bufferLen int
5200  */
5201 #define emberAfFillCommandData                                                                                                     \
5202     SharingClusterRecordTransmission(transmitOptions, buffer, bufferLen)                                                           \
5203         emberAfFillExternalBuffer(mask,                                                                                            \
5204                                                                                                                                    \
5205                                   ZCL_RECORD_TRANSMISSION_COMMAND_ID, "ub", transmitOptions, buffer, bufferLen);
5206
5207 /** @brief Command description for SearchGame
5208  *
5209  * Command: SearchGame
5210  * @param specificGame ENUM8
5211  * @param gameId INT16U
5212  * @param gameId INT16U
5213  * @param gameMaster BOOLEAN
5214  * @param listOfGame CHAR_STRING
5215  */
5216 #define emberAfFillCommandGamingClusterSearchGame(specificGame, gameId, gameId, gameMaster, listOfGame)                            \
5217     emberAfFillExternalBuffer(mask,                                                                                                \
5218                                                                                                                                    \
5219                               ZCL_SEARCH_GAME_COMMAND_ID, "uuuuu", specificGame, gameId, gameId, gameMaster, listOfGame);
5220
5221 /** @brief Command description for JoinGame
5222  *
5223  * Command: JoinGame
5224  * @param gameId INT16U
5225  * @param commandId INT8U
5226  * @param joinAsMaster BOOLEAN
5227  * @param status BITMAP8
5228  * @param nameOfGame CHAR_STRING
5229  * @param message CHAR_STRING
5230  */
5231 #define emberAfFillCommandGamingClusterJoinGame(gameId, commandId, joinAsMaster, status, nameOfGame, message)                      \
5232     emberAfFillExternalBuffer(mask,                                                                                                \
5233                                                                                                                                    \
5234                               ZCL_JOIN_GAME_COMMAND_ID, "uuuuuu", gameId, commandId, joinAsMaster, status, nameOfGame, message);
5235
5236 /** @brief Command description for StartGame
5237  *
5238  * Command: StartGame
5239  */
5240 #define emberAfFillCommandGamingClusterStartGame()                                                                                 \
5241     emberAfFillExternalBuffer(mask,                                                                                                \
5242                                                                                                                                    \
5243                               ZCL_START_GAME_COMMAND_ID, "", );
5244
5245 /** @brief Command description for PauseGame
5246  *
5247  * Command: PauseGame
5248  */
5249 #define emberAfFillCommandGamingClusterPauseGame()                                                                                 \
5250     emberAfFillExternalBuffer(mask,                                                                                                \
5251                                                                                                                                    \
5252                               ZCL_PAUSE_GAME_COMMAND_ID, "", );
5253
5254 /** @brief Command description for ResumeGame
5255  *
5256  * Command: ResumeGame
5257  */
5258 #define emberAfFillCommandGamingClusterResumeGame()                                                                                \
5259     emberAfFillExternalBuffer(mask,                                                                                                \
5260                                                                                                                                    \
5261                               ZCL_RESUME_GAME_COMMAND_ID, "", );
5262
5263 /** @brief Command description for QuitGame
5264  *
5265  * Command: QuitGame
5266  */
5267 #define emberAfFillCommandGamingClusterQuitGame()                                                                                  \
5268     emberAfFillExternalBuffer(mask,                                                                                                \
5269                                                                                                                                    \
5270                               ZCL_QUIT_GAME_COMMAND_ID, "", );
5271
5272 /** @brief Command description for EndGame
5273  *
5274  * Command: EndGame
5275  */
5276 #define emberAfFillCommandGamingClusterEndGame()                                                                                   \
5277     emberAfFillExternalBuffer(mask,                                                                                                \
5278                                                                                                                                    \
5279                               ZCL_END_GAME_COMMAND_ID, "", );
5280
5281 /** @brief Command description for StartOver
5282  *
5283  * Command: StartOver
5284  */
5285 #define emberAfFillCommandGamingClusterStartOver()                                                                                 \
5286     emberAfFillExternalBuffer(mask,                                                                                                \
5287                                                                                                                                    \
5288                               ZCL_START_OVER_COMMAND_ID, "", );
5289
5290 /** @brief Command description for ActionControl
5291  *
5292  * Command: ActionControl
5293  * @param actions BITMAP32
5294  */
5295 #define emberAfFillCommandGamingClusterActionControl(actions)                                                                      \
5296     emberAfFillExternalBuffer(mask,                                                                                                \
5297                                                                                                                                    \
5298                               ZCL_ACTION_CONTROL_COMMAND_ID, "u", actions);
5299
5300 /** @brief Command description for DownloadGame
5301  *
5302  * Command: DownloadGame
5303  */
5304 #define emberAfFillCommandGamingClusterDownloadGame()                                                                              \
5305     emberAfFillExternalBuffer(mask,                                                                                                \
5306                                                                                                                                    \
5307                               ZCL_DOWNLOAD_GAME_COMMAND_ID, "", );
5308
5309 /** @brief Command description for PathCreation
5310  *
5311  * Command: PathCreation
5312  * @param originatorAddress DATA16
5313  * @param originatorAddress DATA16
5314  * @param destinationAddress DATA16
5315  * @param destinationAddress DATA16
5316  * @param dataRate INT8U
5317  * @param dataRate INT8U
5318  */
5319 #define emberAfFillCommandData                                                                                                     \
5320     Rate ControlClusterPathCreation(originatorAddress, originatorAddress, destinationAddress, destinationAddress, dataRate,        \
5321                                     dataRate)                                                                                      \
5322         emberAfFillExternalBuffer(mask,                                                                                            \
5323                                                                                                                                    \
5324                                   ZCL_PATH_CREATION_COMMAND_ID, "uuuuuu", originatorAddress, originatorAddress,                    \
5325                                   destinationAddress, destinationAddress, dataRate, dataRate);
5326
5327 /** @brief Command description for DataRateNotification
5328  *
5329  * Command: DataRateNotification
5330  * @param originatorAddress DATA16
5331  * @param destinationAddress DATA16
5332  * @param dataRate INT8U
5333  */
5334 #define emberAfFillCommandData                                                                                                     \
5335     Rate ControlClusterDataRateNotification(originatorAddress, destinationAddress, dataRate)                                       \
5336         emberAfFillExternalBuffer(mask,                                                                                            \
5337                                                                                                                                    \
5338                                   ZCL_DATA_RATE_NOTIFICATION_COMMAND_ID, "uuu", originatorAddress, destinationAddress, dataRate);
5339
5340 /** @brief Command description for PathDeletion
5341  *
5342  * Command: PathDeletion
5343  * @param originatorAddress DATA16
5344  * @param destinationAddress DATA16
5345  */
5346 #define emberAfFillCommandData                                                                                                     \
5347     Rate ControlClusterPathDeletion(originatorAddress, destinationAddress)                                                         \
5348         emberAfFillExternalBuffer(mask,                                                                                            \
5349                                                                                                                                    \
5350                                   ZCL_PATH_DELETION_COMMAND_ID, "uu", originatorAddress, destinationAddress);
5351
5352 /** @brief Command description for EstablishmentRequest
5353  *
5354  * Command: EstablishmentRequest
5355  * @param flag BITMAP8
5356  * @param ackNack ENUM8
5357  * @param codecType ENUM8
5358  * @param codecType ENUM8
5359  * @param sampFreq ENUM8
5360  * @param codecRate ENUM8
5361  * @param serviceType ENUM8
5362  * @param buffer INT8U []
5363  * @param bufferLen int
5364  */
5365 #define emberAfFillCommandVoice                                                                                                    \
5366     over ZigBeeClusterEstablishmentRequest(flag, ackNack, codecType, codecType, sampFreq, codecRate, serviceType, buffer,          \
5367                                            bufferLen)                                                                              \
5368         emberAfFillExternalBuffer(mask,                                                                                            \
5369                                                                                                                                    \
5370                                   ZCL_ESTABLISHMENT_REQUEST_COMMAND_ID, "uuuuuuub", flag, ackNack, codecType, codecType, sampFreq, \
5371                                   codecRate, serviceType, buffer, bufferLen);
5372
5373 /** @brief Command description for VoiceTransmission
5374  *
5375  * Command: VoiceTransmission
5376  * @param voiceData INT8U []
5377  * @param voiceDataLen int
5378  * @param sequenceNumber INT8U
5379  * @param errorFlag ENUM8
5380  */
5381 #define emberAfFillCommandVoice                                                                                                    \
5382     over ZigBeeClusterVoiceTransmission(voiceData, voiceDataLen, sequenceNumber, errorFlag)                                        \
5383         emberAfFillExternalBuffer(mask,                                                                                            \
5384                                                                                                                                    \
5385                                   ZCL_VOICE_TRANSMISSION_COMMAND_ID, "buu", voiceData, voiceDataLen, sequenceNumber, errorFlag);
5386
5387 /** @brief Command description for VoiceTransmissionCompletion
5388  *
5389  * Command: VoiceTransmissionCompletion
5390  * @param controlType ENUM8
5391  */
5392 #define emberAfFillCommandVoice                                                                                                    \
5393     over ZigBeeClusterVoiceTransmissionCompletion(controlType)                                                                     \
5394         emberAfFillExternalBuffer(mask,                                                                                            \
5395                                                                                                                                    \
5396                                   ZCL_VOICE_TRANSMISSION_COMPLETION_COMMAND_ID, "u", controlType);
5397
5398 /** @brief Command description for ControlResponse
5399  *
5400  * Command: ControlResponse
5401  * @param ackNack ENUM8
5402  */
5403 #define emberAfFillCommandVoice                                                                                                    \
5404     over ZigBeeClusterControlResponse(ackNack) emberAfFillExternalBuffer(mask,                                                     \
5405                                                                                                                                    \
5406                                                                          ZCL_CONTROL_RESPONSE_COMMAND_ID, "u", ackNack);
5407
5408 /** @brief Command description for JoinChatRequest
5409  *
5410  * Command: JoinChatRequest
5411  * @param uid INT16U
5412  * @param status ENUM8
5413  * @param nickname CHAR_STRING
5414  * @param cid INT16U
5415  * @param cid INT16U
5416  */
5417 #define emberAfFillCommandChattingClusterJoinChatRequest(uid, status, nickname, cid, cid)                                          \
5418     emberAfFillExternalBuffer(mask,                                                                                                \
5419                                                                                                                                    \
5420                               ZCL_JOIN_CHAT_REQUEST_COMMAND_ID, "uuuuu", uid, status, nickname, cid, cid);
5421
5422 /** @brief Command description for LeaveChatRequest
5423  *
5424  * Command: LeaveChatRequest
5425  * @param cid INT16U
5426  * @param status ENUM8
5427  * @param uid INT16U
5428  * @param cid INT16U
5429  * @param chatParticipantList ChatParticipant []
5430  * @param chatParticipantListLen int
5431  */
5432 #define emberAfFillCommandChattingClusterLeaveChatRequest(cid, status, uid, cid, chatParticipantList, chatParticipantListLen)      \
5433     emberAfFillExternalBuffer(mask,                                                                                                \
5434                                                                                                                                    \
5435                               ZCL_LEAVE_CHAT_REQUEST_COMMAND_ID, "uuuub", cid, status, uid, cid, chatParticipantList,              \
5436                               chatParticipantListLen);
5437
5438 /** @brief Command description for SearchChatRequest
5439  *
5440  * Command: SearchChatRequest
5441  * @param cid INT16U
5442  * @param uid INT16U
5443  * @param nickname CHAR_STRING
5444  */
5445 #define emberAfFillCommandChattingClusterSearchChatRequest(cid, uid, nickname)                                                     \
5446     emberAfFillExternalBuffer(mask,                                                                                                \
5447                                                                                                                                    \
5448                               ZCL_SEARCH_CHAT_REQUEST_COMMAND_ID, "uuu", cid, uid, nickname);
5449
5450 /** @brief Command description for SwitchChairmanResponse
5451  *
5452  * Command: SwitchChairmanResponse
5453  * @param cid INT16U
5454  * @param cid INT16U
5455  * @param uid INT16U
5456  * @param uid INT16U
5457  * @param nickname CHAR_STRING
5458  */
5459 #define emberAfFillCommandChattingClusterSwitchChairmanResponse(cid, cid, uid, uid, nickname)                                      \
5460     emberAfFillExternalBuffer(mask,                                                                                                \
5461                                                                                                                                    \
5462                               ZCL_SWITCH_CHAIRMAN_RESPONSE_COMMAND_ID, "uuuuu", cid, cid, uid, uid, nickname);
5463
5464 /** @brief Command description for StartChatRequest
5465  *
5466  * Command: StartChatRequest
5467  * @param name CHAR_STRING
5468  * @param options BITMAP8
5469  * @param uid INT16U
5470  * @param chatRoomList ChatRoom []
5471  * @param chatRoomListLen int
5472  * @param nickname CHAR_STRING
5473  */
5474 #define emberAfFillCommandChattingClusterStartChatRequest(name, options, uid, chatRoomList, chatRoomListLen, nickname)             \
5475     emberAfFillExternalBuffer(mask,                                                                                                \
5476                                                                                                                                    \
5477                               ZCL_START_CHAT_REQUEST_COMMAND_ID, "uuubu", name, options, uid, chatRoomList, chatRoomListLen,       \
5478                               nickname);
5479
5480 /** @brief Command description for ChatMessage
5481  *
5482  * Command: ChatMessage
5483  * @param destinationUid INT16U
5484  * @param cid INT16U
5485  * @param sourceUid INT16U
5486  * @param cid INT16U
5487  * @param nickname CHAR_STRING
5488  * @param message CHAR_STRING
5489  */
5490 #define emberAfFillCommandChattingClusterChatMessage(destinationUid, cid, sourceUid, cid, nickname, message)                       \
5491     emberAfFillExternalBuffer(mask,                                                                                                \
5492                                                                                                                                    \
5493                               ZCL_CHAT_MESSAGE_COMMAND_ID, "uuuuuu", destinationUid, cid, sourceUid, cid, nickname, message);
5494
5495 /** @brief Command description for GetNodeInformationRequest
5496  *
5497  * Command: GetNodeInformationRequest
5498  * @param cid INT16U
5499  * @param cid INT16U
5500  * @param uid INT16U
5501  * @param nodeInformationList NodeInformation []
5502  * @param nodeInformationListLen int
5503  */
5504 #define emberAfFillCommandChattingClusterGetNodeInformationRequest(cid, cid, uid, nodeInformationList, nodeInformationListLen)     \
5505     emberAfFillExternalBuffer(mask,                                                                                                \
5506                                                                                                                                    \
5507                               ZCL_GET_NODE_INFORMATION_REQUEST_COMMAND_ID, "uuub", cid, cid, uid, nodeInformationList,             \
5508                               nodeInformationListLen);
5509
5510 /** @brief Command description for SwitchChairmanNotification
5511  *
5512  * Command: SwitchChairmanNotification
5513  * @param cid INT16U
5514  * @param uid INT16U
5515  * @param address DATA16
5516  * @param endpoint INT8U
5517  */
5518 #define emberAfFillCommandChattingClusterSwitchChairmanNotification(cid, uid, address, endpoint)                                   \
5519     emberAfFillExternalBuffer(mask,                                                                                                \
5520                                                                                                                                    \
5521                               ZCL_SWITCH_CHAIRMAN_NOTIFICATION_COMMAND_ID, "uuuu", cid, uid, address, endpoint);
5522
5523 /** @brief Command description for GetNodeInformationResponse
5524  *
5525  * Command: GetNodeInformationResponse
5526  * @param status ENUM8
5527  * @param cid INT16U
5528  * @param uid INT16U
5529  * @param addressEndpointAndNickname INT8U []
5530  * @param addressEndpointAndNicknameLen int
5531  */
5532 #define emberAfFillCommandChattingClusterGetNodeInformationResponse(status, cid, uid, addressEndpointAndNickname,                  \
5533                                                                     addressEndpointAndNicknameLen)                                 \
5534     emberAfFillExternalBuffer(mask,                                                                                                \
5535                                                                                                                                    \
5536                               ZCL_GET_NODE_INFORMATION_RESPONSE_COMMAND_ID, "uuub", status, cid, uid, addressEndpointAndNickname,  \
5537                               addressEndpointAndNicknameLen);
5538
5539 /** @brief Command description for BuyRequest
5540  *
5541  * Command: BuyRequest
5542  * @param userId OCTET_STRING
5543  * @param serialNumber OCTET_STRING
5544  * @param userType INT16U
5545  * @param currency INT32U
5546  * @param serviceId INT16U
5547  * @param priceTrailingDigit INT8U
5548  * @param goodId OCTET_STRING
5549  * @param price INT32U
5550  * @param timestamp OCTET_STRING
5551  * @param transId INT16U
5552  * @param transStatus ENUM8
5553  */
5554 #define emberAfFillCommandPaymentClusterBuyRequest(userId, serialNumber, userType, currency, serviceId, priceTrailingDigit,        \
5555                                                    goodId, price, timestamp, transId, transStatus)                                 \
5556     emberAfFillExternalBuffer(mask,                                                                                                \
5557                                                                                                                                    \
5558                               ZCL_BUY_REQUEST_COMMAND_ID, "uuuuuuuuuuu", userId, serialNumber, userType, currency, serviceId,      \
5559                               priceTrailingDigit, goodId, price, timestamp, transId, transStatus);
5560
5561 /** @brief Command description for AcceptPayment
5562  *
5563  * Command: AcceptPayment
5564  * @param userId OCTET_STRING
5565  * @param serialNumber OCTET_STRING
5566  * @param userType INT16U
5567  * @param currency INT32U
5568  * @param serviceId INT16U
5569  * @param priceTrailingDigit INT8U
5570  * @param goodId OCTET_STRING
5571  * @param price INT32U
5572  * @param timestamp OCTET_STRING
5573  */
5574 #define emberAfFillCommandPaymentClusterAcceptPayment(userId, serialNumber, userType, currency, serviceId, priceTrailingDigit,     \
5575                                                       goodId, price, timestamp)                                                    \
5576     emberAfFillExternalBuffer(mask,                                                                                                \
5577                                                                                                                                    \
5578                               ZCL_ACCEPT_PAYMENT_COMMAND_ID, "uuuuuuuuu", userId, serialNumber, userType, currency, serviceId,     \
5579                               priceTrailingDigit, goodId, price, timestamp);
5580
5581 /** @brief Command description for PaymentConfirm
5582  *
5583  * Command: PaymentConfirm
5584  * @param serialNumber OCTET_STRING
5585  * @param serialNumber OCTET_STRING
5586  * @param transId INT16U
5587  * @param status ENUM8
5588  * @param transStatus ENUM8
5589  */
5590 #define emberAfFillCommandPaymentClusterPaymentConfirm(serialNumber, serialNumber, transId, status, transStatus)                   \
5591     emberAfFillExternalBuffer(mask,                                                                                                \
5592                                                                                                                                    \
5593                               ZCL_PAYMENT_CONFIRM_COMMAND_ID, "uuuuu", serialNumber, serialNumber, transId, status, transStatus);
5594
5595 /** @brief Command description for Subscribe
5596  *
5597  * Command: Subscribe
5598  * @param userId OCTET_STRING
5599  * @param userId OCTET_STRING
5600  * @param serviceId INT16U
5601  * @param serviceId INT16U
5602  * @param serviceProviderId INT16U
5603  * @param serviceProviderId INT16U
5604  */
5605 #define emberAfFillCommandBillingClusterSubscribe(userId, userId, serviceId, serviceId, serviceProviderId, serviceProviderId)      \
5606     emberAfFillExternalBuffer(mask,                                                                                                \
5607                                                                                                                                    \
5608                               ZCL_SUBSCRIBE_COMMAND_ID, "uuuuuu", userId, userId, serviceId, serviceId, serviceProviderId,         \
5609                               serviceProviderId);
5610
5611 /** @brief Command description for Unsubscribe
5612  *
5613  * Command: Unsubscribe
5614  * @param userId OCTET_STRING
5615  * @param userId OCTET_STRING
5616  * @param serviceId INT16U
5617  * @param serviceId INT16U
5618  * @param serviceProviderId INT16U
5619  * @param serviceProviderId INT16U
5620  * @param timestamp OCTET_STRING
5621  * @param duration INT16U
5622  */
5623 #define emberAfFillCommandBillingClusterUnsubscribe(userId, userId, serviceId, serviceId, serviceProviderId, serviceProviderId,    \
5624                                                     timestamp, duration)                                                           \
5625     emberAfFillExternalBuffer(mask,                                                                                                \
5626                                                                                                                                    \
5627                               ZCL_UNSUBSCRIBE_COMMAND_ID, "uuuuuuuu", userId, userId, serviceId, serviceId, serviceProviderId,     \
5628                               serviceProviderId, timestamp, duration);
5629
5630 /** @brief Command description for StartBillingSession
5631  *
5632  * Command: StartBillingSession
5633  * @param userId OCTET_STRING
5634  * @param serviceId INT16U
5635  * @param serviceProviderId INT16U
5636  */
5637 #define emberAfFillCommandBillingClusterStartBillingSession(userId, serviceId, serviceProviderId)                                  \
5638     emberAfFillExternalBuffer(mask,                                                                                                \
5639                                                                                                                                    \
5640                               ZCL_START_BILLING_SESSION_COMMAND_ID, "uuu", userId, serviceId, serviceProviderId);
5641
5642 /** @brief Command description for StopBillingSession
5643  *
5644  * Command: StopBillingSession
5645  * @param userId OCTET_STRING
5646  * @param serviceId INT16U
5647  * @param serviceProviderId INT16U
5648  */
5649 #define emberAfFillCommandBillingClusterStopBillingSession(userId, serviceId, serviceProviderId)                                   \
5650     emberAfFillExternalBuffer(mask,                                                                                                \
5651                                                                                                                                    \
5652                               ZCL_STOP_BILLING_SESSION_COMMAND_ID, "uuu", userId, serviceId, serviceProviderId);
5653
5654 /** @brief Command description for BillStatusNotification
5655  *
5656  * Command: BillStatusNotification
5657  * @param userId OCTET_STRING
5658  * @param status ENUM8
5659  */
5660 #define emberAfFillCommandBillingClusterBillStatusNotification(userId, status)                                                     \
5661     emberAfFillExternalBuffer(mask,                                                                                                \
5662                                                                                                                                    \
5663                               ZCL_BILL_STATUS_NOTIFICATION_COMMAND_ID, "uu", userId, status);
5664
5665 /** @brief Command description for SessionKeepAlive
5666  *
5667  * Command: SessionKeepAlive
5668  * @param userId OCTET_STRING
5669  * @param serviceId INT16U
5670  * @param serviceProviderId INT16U
5671  */
5672 #define emberAfFillCommandBillingClusterSessionKeepAlive(userId, serviceId, serviceProviderId)                                     \
5673     emberAfFillExternalBuffer(mask,                                                                                                \
5674                                                                                                                                    \
5675                               ZCL_SESSION_KEEP_ALIVE_COMMAND_ID, "uuu", userId, serviceId, serviceProviderId);
5676
5677 /** @brief Command description for GetAlerts
5678  *
5679  * Command: GetAlerts
5680  * @param alertsCount AlertCount
5681  * @param alertStructures AlertStructure []
5682  * @param alertStructuresLen int
5683  */
5684 #define emberAfFillCommandAppliance                                                                                                \
5685     Events and AlertClusterGetAlerts(alertsCount, alertStructures, alertStructuresLen)                                             \
5686         emberAfFillExternalBuffer(mask,                                                                                            \
5687                                                                                                                                    \
5688                                   ZCL_GET_ALERTS_COMMAND_ID, "ub", alertsCount, alertStructures, alertStructuresLen);
5689
5690 /** @brief Command description for AlertsNotification
5691  *
5692  * Command: AlertsNotification
5693  * @param alertsCount AlertCount
5694  * @param alertStructures AlertStructure []
5695  * @param alertStructuresLen int
5696  */
5697 #define emberAfFillCommandAppliance                                                                                                \
5698     Events and AlertClusterAlertsNotification(alertsCount, alertStructures, alertStructuresLen)                                    \
5699         emberAfFillExternalBuffer(mask,                                                                                            \
5700                                                                                                                                    \
5701                                   ZCL_ALERTS_NOTIFICATION_COMMAND_ID, "ub", alertsCount, alertStructures, alertStructuresLen);
5702
5703 /** @brief Command description for EventsNotification
5704  *
5705  * Command: EventsNotification
5706  * @param eventHeader INT8U
5707  * @param eventId EventIdentification
5708  */
5709 #define emberAfFillCommandAppliance                                                                                                \
5710     Events and AlertClusterEventsNotification(eventHeader, eventId)                                                                \
5711         emberAfFillExternalBuffer(mask,                                                                                            \
5712                                                                                                                                    \
5713                                   ZCL_EVENTS_NOTIFICATION_COMMAND_ID, "uu", eventHeader, eventId);
5714
5715 /** @brief Command description for LogNotification
5716  *
5717  * Command: LogNotification
5718  * @param timeStamp TIME_OF_DAY
5719  * @param logId INT32U
5720  * @param logId INT32U
5721  * @param logLength INT32U
5722  * @param logPayload INT8U []
5723  * @param logPayloadLen int
5724  */
5725 #define emberAfFillCommandAppliance                                                                                                \
5726     StatisticsClusterLogNotification(timeStamp, logId, logId, logLength, logPayload, logPayloadLen) emberAfFillExternalBuffer(     \
5727         mask,                                                                                                                      \
5728                                                                                                                                    \
5729         ZCL_LOG_NOTIFICATION_COMMAND_ID, "uuuub", timeStamp, logId, logId, logLength, logPayload, logPayloadLen);
5730
5731 /** @brief Command description for LogQueueRequest
5732  *
5733  * Command: LogQueueRequest
5734  * @param timeStamp TIME_OF_DAY
5735  * @param logId INT32U
5736  * @param logLength INT32U
5737  * @param logPayload INT8U []
5738  * @param logPayloadLen int
5739  */
5740 #define emberAfFillCommandAppliance                                                                                                \
5741     StatisticsClusterLogQueueRequest(timeStamp, logId, logLength, logPayload, logPayloadLen) emberAfFillExternalBuffer(            \
5742         mask,                                                                                                                      \
5743                                                                                                                                    \
5744         ZCL_LOG_QUEUE_REQUEST_COMMAND_ID, "uuub", timeStamp, logId, logLength, logPayload, logPayloadLen);
5745
5746 /** @brief Command description for LogQueueResponse
5747  *
5748  * Command: LogQueueResponse
5749  * @param logQueueSize INT8U
5750  * @param logIds INT32U []
5751  * @param logIdsLen int
5752  */
5753 #define emberAfFillCommandAppliance                                                                                                \
5754     StatisticsClusterLogQueueResponse(logQueueSize, logIds, logIdsLen)                                                             \
5755         emberAfFillExternalBuffer(mask,                                                                                            \
5756                                                                                                                                    \
5757                                   ZCL_LOG_QUEUE_RESPONSE_COMMAND_ID, "ub", logQueueSize, logIds, logIdsLen);
5758
5759 /** @brief Command description for StatisticsAvailable
5760  *
5761  * Command: StatisticsAvailable
5762  * @param logQueueSize INT8U
5763  * @param logIds INT32U []
5764  * @param logIdsLen int
5765  */
5766 #define emberAfFillCommandAppliance                                                                                                \
5767     StatisticsClusterStatisticsAvailable(logQueueSize, logIds, logIdsLen)                                                          \
5768         emberAfFillExternalBuffer(mask,                                                                                            \
5769                                                                                                                                    \
5770                                   ZCL_STATISTICS_AVAILABLE_COMMAND_ID, "ub", logQueueSize, logIds, logIdsLen);
5771
5772 /** @brief Command description for GetProfileInfoCommand
5773  *
5774  * Command: GetProfileInfoCommand
5775  * @param profileCount INT8U
5776  * @param profileIntervalPeriod ENUM8
5777  * @param maxNumberOfIntervals INT8U
5778  * @param listOfAttributes INT16U []
5779  * @param listOfAttributesLen int
5780  */
5781 #define emberAfFillCommandElectrical                                                                                               \
5782     MeasurementClusterGetProfileInfoCommand(profileCount, profileIntervalPeriod, maxNumberOfIntervals, listOfAttributes,           \
5783                                             listOfAttributesLen)                                                                   \
5784         emberAfFillExternalBuffer(mask,                                                                                            \
5785                                                                                                                                    \
5786                                   ZCL_GET_PROFILE_INFO_COMMAND_COMMAND_ID, "uuub", profileCount, profileIntervalPeriod,            \
5787                                   maxNumberOfIntervals, listOfAttributes, listOfAttributesLen);
5788
5789 /** @brief Command description for GetMeasurementProfileResponseCommand
5790  *
5791  * Command: GetMeasurementProfileResponseCommand
5792  * @param startTime INT32U
5793  * @param attributeId INT16U
5794  * @param status ENUM8
5795  * @param startTime INT32U
5796  * @param profileIntervalPeriod ENUM8
5797  * @param numberOfIntervals ENUM8
5798  * @param numberOfIntervalsDelivered INT8U
5799  * @param attributeId INT16U
5800  * @param intervals INT8U []
5801  * @param intervalsLen int
5802  */
5803 #define emberAfFillCommandElectrical                                                                                               \
5804     MeasurementClusterGetMeasurementProfileResponseCommand(startTime, attributeId, status, startTime, profileIntervalPeriod,       \
5805                                                            numberOfIntervals, numberOfIntervalsDelivered, attributeId, intervals,  \
5806                                                            intervalsLen)                                                           \
5807         emberAfFillExternalBuffer(mask,                                                                                            \
5808                                                                                                                                    \
5809                                   ZCL_GET_MEASUREMENT_PROFILE_RESPONSE_COMMAND_COMMAND_ID, "uuuuuuuub", startTime, attributeId,    \
5810                                   status, startTime, profileIntervalPeriod, numberOfIntervals, numberOfIntervalsDelivered,         \
5811                                   attributeId, intervals, intervalsLen);
5812
5813 /** @brief Command description for ScanRequest
5814  *
5815  * Command: ScanRequest
5816  * @param transaction INT32U
5817  * @param zigbeeInformation ZigbeeInformation
5818  * @param zllInformation ZllInformation
5819  */
5820 #define emberAfFillCommandZLL                                                                                                      \
5821     CommissioningClusterScanRequest(transaction, zigbeeInformation, zllInformation)                                                \
5822         emberAfFillExternalBuffer(mask,                                                                                            \
5823                                                                                                                                    \
5824                                   ZCL_SCAN_REQUEST_COMMAND_ID, "uuu", transaction, zigbeeInformation, zllInformation);
5825
5826 /** @brief Command description for ScanResponse
5827  *
5828  * Command: ScanResponse
5829  * @param transaction INT32U
5830  * @param rssiCorrection INT8U
5831  * @param zigbeeInformation ZigbeeInformation
5832  * @param zllInformation ZllInformation
5833  * @param keyBitmask KeyBitmask
5834  * @param responseId INT32U
5835  * @param extendedPanId IEEE_ADDRESS
5836  * @param networkUpdateId INT8U
5837  * @param logicalChannel INT8U
5838  * @param panId INT16U
5839  * @param networkAddress INT16U
5840  * @param numberOfSubDevices INT8U
5841  * @param totalGroupIds INT8U
5842  * @param endpointId INT8U
5843  * @param profileId INT16U
5844  * @param deviceId INT16U
5845  * @param version INT8U
5846  * @param groupIdCount INT8U
5847  */
5848 #define emberAfFillCommandZLL                                                                                                      \
5849     CommissioningClusterScanResponse(transaction, rssiCorrection, zigbeeInformation, zllInformation, keyBitmask, responseId,       \
5850                                      extendedPanId, networkUpdateId, logicalChannel, panId, networkAddress, numberOfSubDevices,    \
5851                                      totalGroupIds, endpointId, profileId, deviceId, version, groupIdCount)                        \
5852         emberAfFillExternalBuffer(mask,                                                                                            \
5853                                                                                                                                    \
5854                                   ZCL_SCAN_RESPONSE_COMMAND_ID, "uuuuuuuuuuuuuuuuuu", transaction, rssiCorrection,                 \
5855                                   zigbeeInformation, zllInformation, keyBitmask, responseId, extendedPanId, networkUpdateId,       \
5856                                   logicalChannel, panId, networkAddress, numberOfSubDevices, totalGroupIds, endpointId, profileId, \
5857                                   deviceId, version, groupIdCount);
5858
5859 /** @brief Command description for DeviceInformationRequest
5860  *
5861  * Command: DeviceInformationRequest
5862  * @param transaction INT32U
5863  * @param startIndex INT8U
5864  */
5865 #define emberAfFillCommandZLL                                                                                                      \
5866     CommissioningClusterDeviceInformationRequest(transaction, startIndex)                                                          \
5867         emberAfFillExternalBuffer(mask,                                                                                            \
5868                                                                                                                                    \
5869                                   ZCL_DEVICE_INFORMATION_REQUEST_COMMAND_ID, "uu", transaction, startIndex);
5870
5871 /** @brief Command description for DeviceInformationResponse
5872  *
5873  * Command: DeviceInformationResponse
5874  * @param transaction INT32U
5875  * @param numberOfSubDevices INT8U
5876  * @param startIndex INT8U
5877  * @param deviceInformationRecordCount INT8U
5878  * @param deviceInformationRecordList DeviceInformationRecord []
5879  * @param deviceInformationRecordListLen int
5880  */
5881 #define emberAfFillCommandZLL                                                                                                      \
5882     CommissioningClusterDeviceInformationResponse(transaction, numberOfSubDevices, startIndex, deviceInformationRecordCount,       \
5883                                                   deviceInformationRecordList, deviceInformationRecordListLen)                     \
5884         emberAfFillExternalBuffer(mask,                                                                                            \
5885                                                                                                                                    \
5886                                   ZCL_DEVICE_INFORMATION_RESPONSE_COMMAND_ID, "uuuub", transaction, numberOfSubDevices,            \
5887                                   startIndex, deviceInformationRecordCount, deviceInformationRecordList,                           \
5888                                   deviceInformationRecordListLen);
5889
5890 /** @brief Command description for IdentifyRequest
5891  *
5892  * Command: IdentifyRequest
5893  * @param transaction INT32U
5894  * @param identifyDuration INT16U
5895  */
5896 #define emberAfFillCommandZLL                                                                                                      \
5897     CommissioningClusterIdentifyRequest(transaction, identifyDuration)                                                             \
5898         emberAfFillExternalBuffer(mask,                                                                                            \
5899                                                                                                                                    \
5900                                   ZCL_IDENTIFY_REQUEST_COMMAND_ID, "uu", transaction, identifyDuration);
5901
5902 /** @brief Command description for ResetToFactoryNewRequest
5903  *
5904  * Command: ResetToFactoryNewRequest
5905  * @param transaction INT32U
5906  */
5907 #define emberAfFillCommandZLL                                                                                                      \
5908     CommissioningClusterResetToFactoryNewRequest(transaction)                                                                      \
5909         emberAfFillExternalBuffer(mask,                                                                                            \
5910                                                                                                                                    \
5911                                   ZCL_RESET_TO_FACTORY_NEW_REQUEST_COMMAND_ID, "u", transaction);
5912
5913 /** @brief Command description for NetworkStartRequest
5914  *
5915  * Command: NetworkStartRequest
5916  * @param transaction INT32U
5917  * @param extendedPanId IEEE_ADDRESS
5918  * @param keyIndex KeyIndex
5919  * @param encryptedNetworkKey SECURITY_KEY
5920  * @param logicalChannel INT8U
5921  * @param panId INT16U
5922  * @param networkAddress INT16U
5923  * @param groupIdentifiersBegin INT16U
5924  * @param groupIdentifiersEnd INT16U
5925  * @param freeNetworkAddressRangeBegin INT16U
5926  * @param freeNetworkAddressRangeEnd INT16U
5927  * @param freeGroupIdentifierRangeBegin INT16U
5928  * @param freeGroupIdentifierRangeEnd INT16U
5929  * @param initiatorIeeeAddress IEEE_ADDRESS
5930  * @param initiatorNetworkAddress INT16U
5931  */
5932 #define emberAfFillCommandZLL                                                                                                      \
5933     CommissioningClusterNetworkStartRequest(                                                                                       \
5934         transaction, extendedPanId, keyIndex, encryptedNetworkKey, logicalChannel, panId, networkAddress, groupIdentifiersBegin,   \
5935         groupIdentifiersEnd, freeNetworkAddressRangeBegin, freeNetworkAddressRangeEnd, freeGroupIdentifierRangeBegin,              \
5936         freeGroupIdentifierRangeEnd, initiatorIeeeAddress, initiatorNetworkAddress)                                                \
5937         emberAfFillExternalBuffer(mask,                                                                                            \
5938                                                                                                                                    \
5939                                   ZCL_NETWORK_START_REQUEST_COMMAND_ID, "uuuuuuuuuuuuuuu", transaction, extendedPanId, keyIndex,   \
5940                                   encryptedNetworkKey, logicalChannel, panId, networkAddress, groupIdentifiersBegin,               \
5941                                   groupIdentifiersEnd, freeNetworkAddressRangeBegin, freeNetworkAddressRangeEnd,                   \
5942                                   freeGroupIdentifierRangeBegin, freeGroupIdentifierRangeEnd, initiatorIeeeAddress,                \
5943                                   initiatorNetworkAddress);
5944
5945 /** @brief Command description for NetworkStartResponse
5946  *
5947  * Command: NetworkStartResponse
5948  * @param transaction INT32U
5949  * @param status ZllStatus
5950  * @param extendedPanId IEEE_ADDRESS
5951  * @param networkUpdateId INT8U
5952  * @param logicalChannel INT8U
5953  * @param panId INT16U
5954  */
5955 #define emberAfFillCommandZLL                                                                                                      \
5956     CommissioningClusterNetworkStartResponse(transaction, status, extendedPanId, networkUpdateId, logicalChannel, panId)           \
5957         emberAfFillExternalBuffer(mask,                                                                                            \
5958                                                                                                                                    \
5959                                   ZCL_NETWORK_START_RESPONSE_COMMAND_ID, "uuuuuu", transaction, status, extendedPanId,             \
5960                                   networkUpdateId, logicalChannel, panId);
5961
5962 /** @brief Command description for NetworkJoinRouterRequest
5963  *
5964  * Command: NetworkJoinRouterRequest
5965  * @param transaction INT32U
5966  * @param extendedPanId IEEE_ADDRESS
5967  * @param keyIndex KeyIndex
5968  * @param encryptedNetworkKey SECURITY_KEY
5969  * @param networkUpdateId INT8U
5970  * @param logicalChannel INT8U
5971  * @param panId INT16U
5972  * @param networkAddress INT16U
5973  * @param groupIdentifiersBegin INT16U
5974  * @param groupIdentifiersEnd INT16U
5975  * @param freeNetworkAddressRangeBegin INT16U
5976  * @param freeNetworkAddressRangeEnd INT16U
5977  * @param freeGroupIdentifierRangeBegin INT16U
5978  * @param freeGroupIdentifierRangeEnd INT16U
5979  */
5980 #define emberAfFillCommandZLL                                                                                                      \
5981     CommissioningClusterNetworkJoinRouterRequest(transaction, extendedPanId, keyIndex, encryptedNetworkKey, networkUpdateId,       \
5982                                                  logicalChannel, panId, networkAddress, groupIdentifiersBegin,                     \
5983                                                  groupIdentifiersEnd, freeNetworkAddressRangeBegin, freeNetworkAddressRangeEnd,    \
5984                                                  freeGroupIdentifierRangeBegin, freeGroupIdentifierRangeEnd)                       \
5985         emberAfFillExternalBuffer(mask,                                                                                            \
5986                                                                                                                                    \
5987                                   ZCL_NETWORK_JOIN_ROUTER_REQUEST_COMMAND_ID, "uuuuuuuuuuuuuu", transaction, extendedPanId,        \
5988                                   keyIndex, encryptedNetworkKey, networkUpdateId, logicalChannel, panId, networkAddress,           \
5989                                   groupIdentifiersBegin, groupIdentifiersEnd, freeNetworkAddressRangeBegin,                        \
5990                                   freeNetworkAddressRangeEnd, freeGroupIdentifierRangeBegin, freeGroupIdentifierRangeEnd);
5991
5992 /** @brief Command description for NetworkJoinRouterResponse
5993  *
5994  * Command: NetworkJoinRouterResponse
5995  * @param transaction INT32U
5996  * @param status ZllStatus
5997  */
5998 #define emberAfFillCommandZLL                                                                                                      \
5999     CommissioningClusterNetworkJoinRouterResponse(transaction, status)                                                             \
6000         emberAfFillExternalBuffer(mask,                                                                                            \
6001                                                                                                                                    \
6002                                   ZCL_NETWORK_JOIN_ROUTER_RESPONSE_COMMAND_ID, "uu", transaction, status);
6003
6004 /** @brief Command description for NetworkJoinEndDeviceRequest
6005  *
6006  * Command: NetworkJoinEndDeviceRequest
6007  * @param transaction INT32U
6008  * @param extendedPanId IEEE_ADDRESS
6009  * @param keyIndex KeyIndex
6010  * @param encryptedNetworkKey SECURITY_KEY
6011  * @param networkUpdateId INT8U
6012  * @param logicalChannel INT8U
6013  * @param panId INT16U
6014  * @param networkAddress INT16U
6015  * @param groupIdentifiersBegin INT16U
6016  * @param groupIdentifiersEnd INT16U
6017  * @param freeNetworkAddressRangeBegin INT16U
6018  * @param freeNetworkAddressRangeEnd INT16U
6019  * @param freeGroupIdentifierRangeBegin INT16U
6020  * @param freeGroupIdentifierRangeEnd INT16U
6021  */
6022 #define emberAfFillCommandZLL                                                                                                      \
6023     CommissioningClusterNetworkJoinEndDeviceRequest(transaction, extendedPanId, keyIndex, encryptedNetworkKey, networkUpdateId,    \
6024                                                     logicalChannel, panId, networkAddress, groupIdentifiersBegin,                  \
6025                                                     groupIdentifiersEnd, freeNetworkAddressRangeBegin, freeNetworkAddressRangeEnd, \
6026                                                     freeGroupIdentifierRangeBegin, freeGroupIdentifierRangeEnd)                    \
6027         emberAfFillExternalBuffer(mask,                                                                                            \
6028                                                                                                                                    \
6029                                   ZCL_NETWORK_JOIN_END_DEVICE_REQUEST_COMMAND_ID, "uuuuuuuuuuuuuu", transaction, extendedPanId,    \
6030                                   keyIndex, encryptedNetworkKey, networkUpdateId, logicalChannel, panId, networkAddress,           \
6031                                   groupIdentifiersBegin, groupIdentifiersEnd, freeNetworkAddressRangeBegin,                        \
6032                                   freeNetworkAddressRangeEnd, freeGroupIdentifierRangeBegin, freeGroupIdentifierRangeEnd);
6033
6034 /** @brief Command description for NetworkJoinEndDeviceResponse
6035  *
6036  * Command: NetworkJoinEndDeviceResponse
6037  * @param transaction INT32U
6038  * @param status ZllStatus
6039  */
6040 #define emberAfFillCommandZLL                                                                                                      \
6041     CommissioningClusterNetworkJoinEndDeviceResponse(transaction, status)                                                          \
6042         emberAfFillExternalBuffer(mask,                                                                                            \
6043                                                                                                                                    \
6044                                   ZCL_NETWORK_JOIN_END_DEVICE_RESPONSE_COMMAND_ID, "uu", transaction, status);
6045
6046 /** @brief Command description for NetworkUpdateRequest
6047  *
6048  * Command: NetworkUpdateRequest
6049  * @param transaction INT32U
6050  * @param extendedPanId IEEE_ADDRESS
6051  * @param networkUpdateId INT8U
6052  * @param logicalChannel INT8U
6053  * @param panId INT16U
6054  * @param networkAddress INT16U
6055  */
6056 #define emberAfFillCommandZLL                                                                                                      \
6057     CommissioningClusterNetworkUpdateRequest(transaction, extendedPanId, networkUpdateId, logicalChannel, panId, networkAddress)   \
6058         emberAfFillExternalBuffer(mask,                                                                                            \
6059                                                                                                                                    \
6060                                   ZCL_NETWORK_UPDATE_REQUEST_COMMAND_ID, "uuuuuu", transaction, extendedPanId, networkUpdateId,    \
6061                                   logicalChannel, panId, networkAddress);
6062
6063 /** @brief Command description for EndpointInformation
6064  *
6065  * Command: EndpointInformation
6066  * @param ieeeAddress IEEE_ADDRESS
6067  * @param networkAddress INT16U
6068  * @param endpointId INT8U
6069  * @param profileId INT16U
6070  * @param deviceId INT16U
6071  * @param version INT8U
6072  */
6073 #define emberAfFillCommandZLL                                                                                                      \
6074     CommissioningClusterEndpointInformation(ieeeAddress, networkAddress, endpointId, profileId, deviceId, version)                 \
6075         emberAfFillExternalBuffer(mask,                                                                                            \
6076                                                                                                                                    \
6077                                   ZCL_ENDPOINT_INFORMATION_COMMAND_ID, "uuuuuu", ieeeAddress, networkAddress, endpointId,          \
6078                                   profileId, deviceId, version);
6079
6080 /** @brief Command description for GetGroupIdentifiersRequest
6081  *
6082  * Command: GetGroupIdentifiersRequest
6083  * @param startIndex INT8U
6084  * @param total INT8U
6085  * @param startIndex INT8U
6086  * @param count INT8U
6087  * @param groupInformationRecordList GroupInformationRecord []
6088  * @param groupInformationRecordListLen int
6089  */
6090 #define emberAfFillCommandZLL                                                                                                      \
6091     CommissioningClusterGetGroupIdentifiersRequest(startIndex, total, startIndex, count, groupInformationRecordList,               \
6092                                                    groupInformationRecordListLen)                                                  \
6093         emberAfFillExternalBuffer(mask,                                                                                            \
6094                                                                                                                                    \
6095                                   ZCL_GET_GROUP_IDENTIFIERS_REQUEST_COMMAND_ID, "uuuub", startIndex, total, startIndex, count,     \
6096                                   groupInformationRecordList, groupInformationRecordListLen);
6097
6098 /** @brief Command description for GetEndpointListRequest
6099  *
6100  * Command: GetEndpointListRequest
6101  * @param startIndex INT8U
6102  * @param total INT8U
6103  * @param startIndex INT8U
6104  * @param count INT8U
6105  * @param endpointInformationRecordList EndpointInformationRecord []
6106  * @param endpointInformationRecordListLen int
6107  */
6108 #define emberAfFillCommandZLL                                                                                                      \
6109     CommissioningClusterGetEndpointListRequest(startIndex, total, startIndex, count, endpointInformationRecordList,                \
6110                                                endpointInformationRecordListLen)                                                   \
6111         emberAfFillExternalBuffer(mask,                                                                                            \
6112                                                                                                                                    \
6113                                   ZCL_GET_ENDPOINT_LIST_REQUEST_COMMAND_ID, "uuuub", startIndex, total, startIndex, count,         \
6114                                   endpointInformationRecordList, endpointInformationRecordListLen);
6115
6116 /** @brief Command description for Bind
6117  *
6118  * Command: Bind
6119  * @param nodeId NODE_ID
6120  * @param groupId GROUP_ID
6121  * @param endpointId ENDPOINT_ID
6122  * @param clusterId CLUSTER_ID
6123  */
6124 #define emberAfFillCommandBindingClusterBind(nodeId, groupId, endpointId, clusterId)                                               \
6125     emberAfFillExternalBuffer(mask,                                                                                                \
6126                                                                                                                                    \
6127                               ZCL_BIND_COMMAND_ID, "uuuu", nodeId, groupId, endpointId, clusterId);
6128
6129 /** @brief Command description for Unbind
6130  *
6131  * Command: Unbind
6132  * @param nodeId NODE_ID
6133  * @param groupId GROUP_ID
6134  * @param endpointId ENDPOINT_ID
6135  * @param clusterId CLUSTER_ID
6136  */
6137 #define emberAfFillCommandBindingClusterUnbind(nodeId, groupId, endpointId, clusterId)                                             \
6138     emberAfFillExternalBuffer(mask,                                                                                                \
6139                                                                                                                                    \
6140                               ZCL_UNBIND_COMMAND_ID, "uuuu", nodeId, groupId, endpointId, clusterId);
6141
6142 /** @brief Command description for CommandOne
6143  *
6144  * Command: CommandOne
6145  * @param argOne INT8U
6146  * @param argOne INT8U
6147  */
6148 #define emberAfFillCommandSample                                                                                                   \
6149     Mfg Specific ClusterClusterCommandOne(argOne, argOne)                                                                          \
6150         emberAfFillExternalBuffer(mask,                                                                                            \
6151                                                                                                                                    \
6152                                   ZCL_COMMAND_ONE_COMMAND_ID, "uu", argOne, argOne);
6153
6154 /** @brief Command description for SetToken
6155  *
6156  * Command: SetToken
6157  * @param token INT16U
6158  * @param token INT16U
6159  * @param data OCTET_STRING
6160  * @param data OCTET_STRING
6161  */
6162 #define emberAfFillCommandConfiguration                                                                                            \
6163     ClusterClusterSetToken(token, token, data, data)                                                                               \
6164         emberAfFillExternalBuffer(mask,                                                                                            \
6165                                                                                                                                    \
6166                                   ZCL_SET_TOKEN_COMMAND_ID, "uuuu", token, token, data, data);
6167
6168 /** @brief Command description for LockTokens
6169  *
6170  * Command: LockTokens
6171  */
6172 #define emberAfFillCommandConfiguration                                                                                            \
6173     ClusterClusterLockTokens() emberAfFillExternalBuffer(mask,                                                                     \
6174                                                                                                                                    \
6175                                                          ZCL_LOCK_TOKENS_COMMAND_ID, "", );
6176
6177 /** @brief Command description for ReadTokens
6178  *
6179  * Command: ReadTokens
6180  * @param token INT16U
6181  */
6182 #define emberAfFillCommandConfiguration                                                                                            \
6183     ClusterClusterReadTokens(token) emberAfFillExternalBuffer(mask,                                                                \
6184                                                                                                                                    \
6185                                                               ZCL_READ_TOKENS_COMMAND_ID, "u", token);
6186
6187 /** @brief Command description for UnlockTokens
6188  *
6189  * Command: UnlockTokens
6190  * @param data OCTET_STRING
6191  */
6192 #define emberAfFillCommandConfiguration                                                                                            \
6193     ClusterClusterUnlockTokens(data) emberAfFillExternalBuffer(mask,                                                               \
6194                                                                                                                                    \
6195                                                                ZCL_UNLOCK_TOKENS_COMMAND_ID, "u", data);
6196
6197 /** @brief Command description for stream
6198  *
6199  * Command: stream
6200  * @param channel INT8U
6201  * @param power INT8S
6202  * @param time INT16U
6203  */
6204 #define emberAfFillCommandMFGLIB                                                                                                   \
6205     ClusterClusterstream(channel, power, time) emberAfFillExternalBuffer(mask,                                                     \
6206                                                                                                                                    \
6207                                                                          ZCL_STREAM_COMMAND_ID, "uuu", channel, power, time);
6208
6209 /** @brief Command description for tone
6210  *
6211  * Command: tone
6212  * @param channel INT8U
6213  * @param power INT8S
6214  * @param time INT16U
6215  */
6216 #define emberAfFillCommandMFGLIB                                                                                                   \
6217     ClusterClustertone(channel, power, time) emberAfFillExternalBuffer(mask,                                                       \
6218                                                                                                                                    \
6219                                                                        ZCL_TONE_COMMAND_ID, "uuu", channel, power, time);
6220
6221 /** @brief Command description for rxMode
6222  *
6223  * Command: rxMode
6224  * @param channel INT8U
6225  * @param power INT8S
6226  * @param time INT16U
6227  */
6228 #define emberAfFillCommandMFGLIB                                                                                                   \
6229     ClusterClusterrxMode(channel, power, time) emberAfFillExternalBuffer(mask,                                                     \
6230                                                                                                                                    \
6231                                                                          ZCL_RX_MODE_COMMAND_ID, "uuu", channel, power, time);
6232
6233 /** @brief Command description for EnableApsLinkKeyAuthorization
6234  *
6235  * Command: EnableApsLinkKeyAuthorization
6236  * @param numberExemptClusters INT8U
6237  * @param clusterId CLUSTER_ID
6238  * @param clusterId CLUSTER_ID []
6239  * @param clusterIdLen int
6240  * @param apsLinkKeyAuthStatus BOOLEAN
6241  */
6242 #define emberAfFillCommandSL                                                                                                       \
6243     Works With All HubsClusterEnableApsLinkKeyAuthorization(numberExemptClusters, clusterId, clusterId, clusterIdLen,              \
6244                                                             apsLinkKeyAuthStatus)                                                  \
6245         emberAfFillExternalBuffer(mask,                                                                                            \
6246                                                                                                                                    \
6247                                   ZCL_ENABLE_APS_LINK_KEY_AUTHORIZATION_COMMAND_ID, "uubu", numberExemptClusters, clusterId,       \
6248                                   clusterId, clusterIdLen, apsLinkKeyAuthStatus);
6249
6250 /** @brief Command description for DisableApsLinkKeyAuthorization
6251  *
6252  * Command: DisableApsLinkKeyAuthorization
6253  * @param numberExemptClusters INT8U
6254  * @param powerNotificationReason WwahPowerNotificationReason
6255  * @param clusterId CLUSTER_ID []
6256  * @param clusterIdLen int
6257  * @param manufacturerId INT16U
6258  * @param manufacturerReasonLength INT8U
6259  * @param manufacturerReason INT8U []
6260  * @param manufacturerReasonLen int
6261  */
6262 #define emberAfFillCommandSL                                                                                                       \
6263     Works With All HubsClusterDisableApsLinkKeyAuthorization(numberExemptClusters, powerNotificationReason, clusterId,             \
6264                                                              clusterIdLen, manufacturerId, manufacturerReasonLength,               \
6265                                                              manufacturerReason, manufacturerReasonLen)                            \
6266         emberAfFillExternalBuffer(mask,                                                                                            \
6267                                                                                                                                    \
6268                                   ZCL_DISABLE_APS_LINK_KEY_AUTHORIZATION_COMMAND_ID, "uubuub", numberExemptClusters,               \
6269                                   powerNotificationReason, clusterId, clusterIdLen, manufacturerId, manufacturerReasonLength,      \
6270                                   manufacturerReason, manufacturerReasonLen);
6271
6272 /** @brief Command description for ApsLinkKeyAuthorizationQuery
6273  *
6274  * Command: ApsLinkKeyAuthorizationQuery
6275  * @param clusterId CLUSTER_ID
6276  * @param powerNotificationReason WwahPowerNotificationReason
6277  * @param manufacturerId INT16U
6278  * @param manufacturerReasonLength INT8U
6279  * @param manufacturerReason INT8U []
6280  * @param manufacturerReasonLen int
6281  */
6282 #define emberAfFillCommandSL                                                                                                       \
6283     Works With All HubsClusterApsLinkKeyAuthorizationQuery(clusterId, powerNotificationReason, manufacturerId,                     \
6284                                                            manufacturerReasonLength, manufacturerReason, manufacturerReasonLen)    \
6285         emberAfFillExternalBuffer(mask,                                                                                            \
6286                                                                                                                                    \
6287                                   ZCL_APS_LINK_KEY_AUTHORIZATION_QUERY_COMMAND_ID, "uuuub", clusterId, powerNotificationReason,    \
6288                                   manufacturerId, manufacturerReasonLength, manufacturerReason, manufacturerReasonLen);
6289
6290 /** @brief Command description for RequestNewApsLinkKey
6291  *
6292  * Command: RequestNewApsLinkKey
6293  * @param deviceEui64 IEEE_ADDRESS
6294  * @param deviceShort INT16U
6295  */
6296 #define emberAfFillCommandSL                                                                                                       \
6297     Works With All HubsClusterRequestNewApsLinkKey(deviceEui64, deviceShort)                                                       \
6298         emberAfFillExternalBuffer(mask,                                                                                            \
6299                                                                                                                                    \
6300                                   ZCL_REQUEST_NEW_APS_LINK_KEY_COMMAND_ID, "uu", deviceEui64, deviceShort);
6301
6302 /** @brief Command description for EnableWwahAppEventRetryAlgorithm
6303  *
6304  * Command: EnableWwahAppEventRetryAlgorithm
6305  * @param firstBackoffTimeSeconds INT8U
6306  * @param numberExemptClusters INT8U
6307  * @param backoffSeqCommonRatio INT8U
6308  * @param clusterId CLUSTER_ID []
6309  * @param clusterIdLen int
6310  * @param maxBackoffTimeSeconds INT32U
6311  * @param maxRedeliveryAttempts INT8U
6312  */
6313 #define emberAfFillCommandSL                                                                                                       \
6314     Works With All HubsClusterEnableWwahAppEventRetryAlgorithm(                                                                    \
6315         firstBackoffTimeSeconds, numberExemptClusters, backoffSeqCommonRatio, clusterId, clusterIdLen, maxBackoffTimeSeconds,      \
6316         maxRedeliveryAttempts) emberAfFillExternalBuffer(mask,                                                                     \
6317                                                                                                                                    \
6318                                                          ZCL_ENABLE_WWAH_APP_EVENT_RETRY_ALGORITHM_COMMAND_ID, "uuubuu",           \
6319                                                          firstBackoffTimeSeconds, numberExemptClusters, backoffSeqCommonRatio,     \
6320                                                          clusterId, clusterIdLen, maxBackoffTimeSeconds, maxRedeliveryAttempts);
6321
6322 /** @brief Command description for DisableWwahAppEventRetryAlgorithm
6323  *
6324  * Command: DisableWwahAppEventRetryAlgorithm
6325  * @param currentPowerMode INT32U
6326  * @param availablePowerSources INT32U
6327  * @param currentPowerSource INT32U
6328  * @param currentPowerSourceLevel INT32U
6329  */
6330 #define emberAfFillCommandSL                                                                                                       \
6331     Works With All HubsClusterDisableWwahAppEventRetryAlgorithm(currentPowerMode, availablePowerSources, currentPowerSource,       \
6332                                                                 currentPowerSourceLevel)                                           \
6333         emberAfFillExternalBuffer(mask,                                                                                            \
6334                                                                                                                                    \
6335                                   ZCL_DISABLE_WWAH_APP_EVENT_RETRY_ALGORITHM_COMMAND_ID, "uuuu", currentPowerMode,                 \
6336                                   availablePowerSources, currentPowerSource, currentPowerSourceLevel);
6337
6338 /** @brief Command description for RequestTime
6339  *
6340  * Command: RequestTime
6341  * @param debugReportId INT8U
6342  * @param debugReportSize INT32U
6343  */
6344 #define emberAfFillCommandSL                                                                                                       \
6345     Works With All HubsClusterRequestTime(debugReportId, debugReportSize)                                                          \
6346         emberAfFillExternalBuffer(mask,                                                                                            \
6347                                                                                                                                    \
6348                                   ZCL_REQUEST_TIME_COMMAND_ID, "uu", debugReportId, debugReportSize);
6349
6350 /** @brief Command description for EnableWwahRejoinAlgorithm
6351  *
6352  * Command: EnableWwahRejoinAlgorithm
6353  * @param fastRejoinTimeoutSeconds INT16U
6354  * @param debugReportId INT8U
6355  * @param durationBetweenRejoinsSeconds INT16U
6356  * @param debugReportData INT8U []
6357  * @param debugReportDataLen int
6358  * @param fastRejoinFirstBackoffSeconds INT16U
6359  * @param maxBackoffTimeSeconds INT16U
6360  * @param maxBackoffIterations INT16U
6361  */
6362 #define emberAfFillCommandSL                                                                                                       \
6363     Works With All HubsClusterEnableWwahRejoinAlgorithm(fastRejoinTimeoutSeconds, debugReportId, durationBetweenRejoinsSeconds,    \
6364                                                         debugReportData, debugReportDataLen, fastRejoinFirstBackoffSeconds,        \
6365                                                         maxBackoffTimeSeconds, maxBackoffIterations)                               \
6366         emberAfFillExternalBuffer(mask,                                                                                            \
6367                                                                                                                                    \
6368                                   ZCL_ENABLE_WWAH_REJOIN_ALGORITHM_COMMAND_ID, "uuubuuu", fastRejoinTimeoutSeconds, debugReportId, \
6369                                   durationBetweenRejoinsSeconds, debugReportData, debugReportDataLen,                              \
6370                                   fastRejoinFirstBackoffSeconds, maxBackoffTimeSeconds, maxBackoffIterations);
6371
6372 /** @brief Command description for DisableWwahRejoinAlgorithm
6373  *
6374  * Command: DisableWwahRejoinAlgorithm
6375  * @param numberOfClusters INT8U
6376  * @param clusterId CLUSTER_ID []
6377  * @param clusterIdLen int
6378  */
6379 #define emberAfFillCommandSL                                                                                                       \
6380     Works With All HubsClusterDisableWwahRejoinAlgorithm(numberOfClusters, clusterId, clusterIdLen)                                \
6381         emberAfFillExternalBuffer(mask,                                                                                            \
6382                                                                                                                                    \
6383                                   ZCL_DISABLE_WWAH_REJOIN_ALGORITHM_COMMAND_ID, "ub", numberOfClusters, clusterId, clusterIdLen);
6384
6385 /** @brief Command description for SetIasZoneEnrollmentMethod
6386  *
6387  * Command: SetIasZoneEnrollmentMethod
6388  * @param enrollmentMode WwahIasZoneEnrollmentMode
6389  * @param numberOfBeacons INT8U
6390  * @param beacon WwahBeaconSurvey []
6391  * @param beaconLen int
6392  */
6393 #define emberAfFillCommandSL                                                                                                       \
6394     Works With All HubsClusterSetIasZoneEnrollmentMethod(enrollmentMode, numberOfBeacons, beacon, beaconLen)                       \
6395         emberAfFillExternalBuffer(mask,                                                                                            \
6396                                                                                                                                    \
6397                                   ZCL_SET_IAS_ZONE_ENROLLMENT_METHOD_COMMAND_ID, "uub", enrollmentMode, numberOfBeacons, beacon,   \
6398                                   beaconLen);
6399
6400 /** @brief Command description for ClearBindingTable
6401  *
6402  * Command: ClearBindingTable
6403  */
6404 #define emberAfFillCommandSL                                                                                                       \
6405     Works With All HubsClusterClearBindingTable() emberAfFillExternalBuffer(mask,                                                  \
6406                                                                                                                                    \
6407                                                                             ZCL_CLEAR_BINDING_TABLE_COMMAND_ID, "", );
6408
6409 /** @brief Command description for EnablePeriodicRouterCheckIns
6410  *
6411  * Command: EnablePeriodicRouterCheckIns
6412  * @param checkInInterval INT16U
6413  */
6414 #define emberAfFillCommandSL                                                                                                       \
6415     Works With All HubsClusterEnablePeriodicRouterCheckIns(checkInInterval)                                                        \
6416         emberAfFillExternalBuffer(mask,                                                                                            \
6417                                                                                                                                    \
6418                                   ZCL_ENABLE_PERIODIC_ROUTER_CHECK_INS_COMMAND_ID, "u", checkInInterval);
6419
6420 /** @brief Command description for DisablePeriodicRouterCheckIns
6421  *
6422  * Command: DisablePeriodicRouterCheckIns
6423  */
6424 #define emberAfFillCommandSL                                                                                                       \
6425     Works With All HubsClusterDisablePeriodicRouterCheckIns()                                                                      \
6426         emberAfFillExternalBuffer(mask,                                                                                            \
6427                                                                                                                                    \
6428                                   ZCL_DISABLE_PERIODIC_ROUTER_CHECK_INS_COMMAND_ID, "", );
6429
6430 /** @brief Command description for SetMacPollFailureWaitTime
6431  *
6432  * Command: SetMacPollFailureWaitTime
6433  * @param waitTime INT8U
6434  */
6435 #define emberAfFillCommandSL                                                                                                       \
6436     Works With All HubsClusterSetMacPollFailureWaitTime(waitTime)                                                                  \
6437         emberAfFillExternalBuffer(mask,                                                                                            \
6438                                                                                                                                    \
6439                                   ZCL_SET_MAC_POLL_FAILURE_WAIT_TIME_COMMAND_ID, "u", waitTime);
6440
6441 /** @brief Command description for SetPendingNetworkUpdate
6442  *
6443  * Command: SetPendingNetworkUpdate
6444  * @param channel INT8U
6445  * @param panId INT16U
6446  */
6447 #define emberAfFillCommandSL                                                                                                       \
6448     Works With All HubsClusterSetPendingNetworkUpdate(channel, panId)                                                              \
6449         emberAfFillExternalBuffer(mask,                                                                                            \
6450                                                                                                                                    \
6451                                   ZCL_SET_PENDING_NETWORK_UPDATE_COMMAND_ID, "uu", channel, panId);
6452
6453 /** @brief Command description for RequireApsAcksOnUnicasts
6454  *
6455  * Command: RequireApsAcksOnUnicasts
6456  * @param numberExemptClusters INT8U
6457  * @param clusterId CLUSTER_ID []
6458  * @param clusterIdLen int
6459  */
6460 #define emberAfFillCommandSL                                                                                                       \
6461     Works With All HubsClusterRequireApsAcksOnUnicasts(numberExemptClusters, clusterId, clusterIdLen) emberAfFillExternalBuffer(   \
6462         mask,                                                                                                                      \
6463                                                                                                                                    \
6464         ZCL_REQUIRE_APS_ACKS_ON_UNICASTS_COMMAND_ID, "ub", numberExemptClusters, clusterId, clusterIdLen);
6465
6466 /** @brief Command description for RemoveApsAcksOnUnicastsRequirement
6467  *
6468  * Command: RemoveApsAcksOnUnicastsRequirement
6469  */
6470 #define emberAfFillCommandSL                                                                                                       \
6471     Works With All HubsClusterRemoveApsAcksOnUnicastsRequirement()                                                                 \
6472         emberAfFillExternalBuffer(mask,                                                                                            \
6473                                                                                                                                    \
6474                                   ZCL_REMOVE_APS_ACKS_ON_UNICASTS_REQUIREMENT_COMMAND_ID, "", );
6475
6476 /** @brief Command description for ApsAckRequirementQuery
6477  *
6478  * Command: ApsAckRequirementQuery
6479  */
6480 #define emberAfFillCommandSL                                                                                                       \
6481     Works With All HubsClusterApsAckRequirementQuery() emberAfFillExternalBuffer(mask,                                             \
6482                                                                                                                                    \
6483                                                                                  ZCL_APS_ACK_REQUIREMENT_QUERY_COMMAND_ID, "", );
6484
6485 /** @brief Command description for DebugReportQuery
6486  *
6487  * Command: DebugReportQuery
6488  * @param debugReportId INT8U
6489  */
6490 #define emberAfFillCommandSL                                                                                                       \
6491     Works With All HubsClusterDebugReportQuery(debugReportId)                                                                      \
6492         emberAfFillExternalBuffer(mask,                                                                                            \
6493                                                                                                                                    \
6494                                   ZCL_DEBUG_REPORT_QUERY_COMMAND_ID, "u", debugReportId);
6495
6496 /** @brief Command description for SurveyBeacons
6497  *
6498  * Command: SurveyBeacons
6499  * @param standardBeacons BOOLEAN
6500  */
6501 #define emberAfFillCommandSL                                                                                                       \
6502     Works With All HubsClusterSurveyBeacons(standardBeacons)                                                                       \
6503         emberAfFillExternalBuffer(mask,                                                                                            \
6504                                                                                                                                    \
6505                                   ZCL_SURVEY_BEACONS_COMMAND_ID, "u", standardBeacons);
6506
6507 /** @brief Command description for DisableOtaDowngrades
6508  *
6509  * Command: DisableOtaDowngrades
6510  */
6511 #define emberAfFillCommandSL                                                                                                       \
6512     Works With All HubsClusterDisableOtaDowngrades() emberAfFillExternalBuffer(mask,                                               \
6513                                                                                                                                    \
6514                                                                                ZCL_DISABLE_OTA_DOWNGRADES_COMMAND_ID, "", );
6515
6516 /** @brief Command description for DisableMgmtLeaveWithoutRejoin
6517  *
6518  * Command: DisableMgmtLeaveWithoutRejoin
6519  */
6520 #define emberAfFillCommandSL                                                                                                       \
6521     Works With All HubsClusterDisableMgmtLeaveWithoutRejoin()                                                                      \
6522         emberAfFillExternalBuffer(mask,                                                                                            \
6523                                                                                                                                    \
6524                                   ZCL_DISABLE_MGMT_LEAVE_WITHOUT_REJOIN_COMMAND_ID, "", );
6525
6526 /** @brief Command description for DisableTouchlinkInterpanMessageSupport
6527  *
6528  * Command: DisableTouchlinkInterpanMessageSupport
6529  */
6530 #define emberAfFillCommandSL                                                                                                       \
6531     Works With All HubsClusterDisableTouchlinkInterpanMessageSupport()                                                             \
6532         emberAfFillExternalBuffer(mask,                                                                                            \
6533                                                                                                                                    \
6534                                   ZCL_DISABLE_TOUCHLINK_INTERPAN_MESSAGE_SUPPORT_COMMAND_ID, "", );
6535
6536 /** @brief Command description for EnableWwahParentClassification
6537  *
6538  * Command: EnableWwahParentClassification
6539  */
6540 #define emberAfFillCommandSL                                                                                                       \
6541     Works With All HubsClusterEnableWwahParentClassification()                                                                     \
6542         emberAfFillExternalBuffer(mask,                                                                                            \
6543                                                                                                                                    \
6544                                   ZCL_ENABLE_WWAH_PARENT_CLASSIFICATION_COMMAND_ID, "", );
6545
6546 /** @brief Command description for DisableWwahParentClassification
6547  *
6548  * Command: DisableWwahParentClassification
6549  */
6550 #define emberAfFillCommandSL                                                                                                       \
6551     Works With All HubsClusterDisableWwahParentClassification()                                                                    \
6552         emberAfFillExternalBuffer(mask,                                                                                            \
6553                                                                                                                                    \
6554                                   ZCL_DISABLE_WWAH_PARENT_CLASSIFICATION_COMMAND_ID, "", );
6555
6556 /** @brief Command description for EnableTcSecurityOnNtwkKeyRotation
6557  *
6558  * Command: EnableTcSecurityOnNtwkKeyRotation
6559  */
6560 #define emberAfFillCommandSL                                                                                                       \
6561     Works With All HubsClusterEnableTcSecurityOnNtwkKeyRotation()                                                                  \
6562         emberAfFillExternalBuffer(mask,                                                                                            \
6563                                                                                                                                    \
6564                                   ZCL_ENABLE_TC_SECURITY_ON_NTWK_KEY_ROTATION_COMMAND_ID, "", );
6565
6566 /** @brief Command description for EnableWwahBadParentRecovery
6567  *
6568  * Command: EnableWwahBadParentRecovery
6569  */
6570 #define emberAfFillCommandSL                                                                                                       \
6571     Works With All HubsClusterEnableWwahBadParentRecovery()                                                                        \
6572         emberAfFillExternalBuffer(mask,                                                                                            \
6573                                                                                                                                    \
6574                                   ZCL_ENABLE_WWAH_BAD_PARENT_RECOVERY_COMMAND_ID, "", );
6575
6576 /** @brief Command description for DisableWwahBadParentRecovery
6577  *
6578  * Command: DisableWwahBadParentRecovery
6579  */
6580 #define emberAfFillCommandSL                                                                                                       \
6581     Works With All HubsClusterDisableWwahBadParentRecovery()                                                                       \
6582         emberAfFillExternalBuffer(mask,                                                                                            \
6583                                                                                                                                    \
6584                                   ZCL_DISABLE_WWAH_BAD_PARENT_RECOVERY_COMMAND_ID, "", );
6585
6586 /** @brief Command description for EnableConfigurationMode
6587  *
6588  * Command: EnableConfigurationMode
6589  */
6590 #define emberAfFillCommandSL                                                                                                       \
6591     Works With All HubsClusterEnableConfigurationMode() emberAfFillExternalBuffer(mask,                                            \
6592                                                                                                                                    \
6593                                                                                   ZCL_ENABLE_CONFIGURATION_MODE_COMMAND_ID, "", );
6594
6595 /** @brief Command description for DisableConfigurationMode
6596  *
6597  * Command: DisableConfigurationMode
6598  */
6599 #define emberAfFillCommandSL                                                                                                       \
6600     Works With All HubsClusterDisableConfigurationMode()                                                                           \
6601         emberAfFillExternalBuffer(mask,                                                                                            \
6602                                                                                                                                    \
6603                                   ZCL_DISABLE_CONFIGURATION_MODE_COMMAND_ID, "", );
6604
6605 /** @brief Command description for UseTrustCenterForClusterServer
6606  *
6607  * Command: UseTrustCenterForClusterServer
6608  * @param numberOfClusters INT8U
6609  * @param clusterId CLUSTER_ID []
6610  * @param clusterIdLen int
6611  */
6612 #define emberAfFillCommandSL                                                                                                       \
6613     Works With All HubsClusterUseTrustCenterForClusterServer(numberOfClusters, clusterId, clusterIdLen) emberAfFillExternalBuffer( \
6614         mask,                                                                                                                      \
6615                                                                                                                                    \
6616         ZCL_USE_TRUST_CENTER_FOR_CLUSTER_SERVER_COMMAND_ID, "ub", numberOfClusters, clusterId, clusterIdLen);
6617
6618 /** @brief Command description for TrustCenterForClusterServerQuery
6619  *
6620  * Command: TrustCenterForClusterServerQuery
6621  */
6622 #define emberAfFillCommandSL                                                                                                       \
6623     Works With All HubsClusterTrustCenterForClusterServerQuery()                                                                   \
6624         emberAfFillExternalBuffer(mask,                                                                                            \
6625                                                                                                                                    \
6626                                   ZCL_TRUST_CENTER_FOR_CLUSTER_SERVER_QUERY_COMMAND_ID, "", );
6627
6628 /** @brief Command description for UseTrustCenterForClusterServerResponse
6629  *
6630  * Command: UseTrustCenterForClusterServerResponse
6631  * @param status Status
6632  * @param clusterStatusLength INT8U
6633  * @param clusterStatus WwahClusterStatusToUseTC []
6634  * @param clusterStatusLen int
6635  */
6636 #define emberAfFillCommandSL                                                                                                       \
6637     Works With All HubsClusterUseTrustCenterForClusterServerResponse(status, clusterStatusLength, clusterStatus, clusterStatusLen) \
6638         emberAfFillExternalBuffer(mask,                                                                                            \
6639                                                                                                                                    \
6640                                   ZCL_USE_TRUST_CENTER_FOR_CLUSTER_SERVER_RESPONSE_COMMAND_ID, "uub", status, clusterStatusLength, \
6641                                   clusterStatus, clusterStatusLen);