examples/tv-app/tv-common/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 LockDoor
1915  *
1916  * Command: LockDoor
1917  * @param PIN CHAR_STRING
1918  * @param status INT8U
1919  */
1920 #define emberAfFillCommandDoor                                                                                                     \
1921     LockClusterLockDoor(PIN, status) emberAfFillExternalBuffer(mask,                                                               \
1922                                                                                                                                    \
1923                                                                ZCL_LOCK_DOOR_COMMAND_ID, "uu", PIN, status);
1924
1925 /** @brief Command description for UnlockDoor
1926  *
1927  * Command: UnlockDoor
1928  * @param PIN CHAR_STRING
1929  * @param status INT8U
1930  */
1931 #define emberAfFillCommandDoor                                                                                                     \
1932     LockClusterUnlockDoor(PIN, status) emberAfFillExternalBuffer(mask,                                                             \
1933                                                                                                                                    \
1934                                                                  ZCL_UNLOCK_DOOR_COMMAND_ID, "uu", PIN, status);
1935
1936 /** @brief Command description for Toggle
1937  *
1938  * Command: Toggle
1939  * @param pin CHAR_STRING
1940  * @param status INT8U
1941  */
1942 #define emberAfFillCommandDoor                                                                                                     \
1943     LockClusterToggle(pin, status) emberAfFillExternalBuffer(mask,                                                                 \
1944                                                                                                                                    \
1945                                                              ZCL_TOGGLE_COMMAND_ID, "uu", pin, status);
1946
1947 /** @brief Command description for UnlockWithTimeout
1948  *
1949  * Command: UnlockWithTimeout
1950  * @param timeoutInSeconds INT16U
1951  * @param status INT8U
1952  * @param pin CHAR_STRING
1953  */
1954 #define emberAfFillCommandDoor                                                                                                     \
1955     LockClusterUnlockWithTimeout(timeoutInSeconds, status, pin)                                                                    \
1956         emberAfFillExternalBuffer(mask,                                                                                            \
1957                                                                                                                                    \
1958                                   ZCL_UNLOCK_WITH_TIMEOUT_COMMAND_ID, "uuu", timeoutInSeconds, status, pin);
1959
1960 /** @brief Command description for GetLogRecord
1961  *
1962  * Command: GetLogRecord
1963  * @param logIndex INT16U
1964  * @param logEntryId INT16U
1965  * @param timestamp INT32U
1966  * @param eventType ENUM8
1967  * @param source INT8U
1968  * @param eventIdOrAlarmCode INT8U
1969  * @param userId INT16U
1970  * @param pin CHAR_STRING
1971  */
1972 #define emberAfFillCommandDoor                                                                                                     \
1973     LockClusterGetLogRecord(logIndex, logEntryId, timestamp, eventType, source, eventIdOrAlarmCode, userId, pin)                   \
1974         emberAfFillExternalBuffer(mask,                                                                                            \
1975                                                                                                                                    \
1976                                   ZCL_GET_LOG_RECORD_COMMAND_ID, "uuuuuuuu", logIndex, logEntryId, timestamp, eventType, source,   \
1977                                   eventIdOrAlarmCode, userId, pin);
1978
1979 /** @brief Command description for SetPin
1980  *
1981  * Command: SetPin
1982  * @param userId INT16U
1983  * @param status DoorLockSetPinOrIdStatus
1984  * @param userStatus DoorLockUserStatus
1985  * @param userType DoorLockUserType
1986  * @param pin CHAR_STRING
1987  */
1988 #define emberAfFillCommandDoor                                                                                                     \
1989     LockClusterSetPin(userId, status, userStatus, userType, pin)                                                                   \
1990         emberAfFillExternalBuffer(mask,                                                                                            \
1991                                                                                                                                    \
1992                                   ZCL_SET_PIN_COMMAND_ID, "uuuuu", userId, status, userStatus, userType, pin);
1993
1994 /** @brief Command description for GetPin
1995  *
1996  * Command: GetPin
1997  * @param userId INT16U
1998  * @param userId INT16U
1999  * @param userStatus DoorLockUserStatus
2000  * @param userType DoorLockUserType
2001  * @param pin CHAR_STRING
2002  */
2003 #define emberAfFillCommandDoor                                                                                                     \
2004     LockClusterGetPin(userId, userId, userStatus, userType, pin)                                                                   \
2005         emberAfFillExternalBuffer(mask,                                                                                            \
2006                                                                                                                                    \
2007                                   ZCL_GET_PIN_COMMAND_ID, "uuuuu", userId, userId, userStatus, userType, pin);
2008
2009 /** @brief Command description for ClearPin
2010  *
2011  * Command: ClearPin
2012  * @param userId INT16U
2013  * @param status INT8U
2014  */
2015 #define emberAfFillCommandDoor                                                                                                     \
2016     LockClusterClearPin(userId, status) emberAfFillExternalBuffer(mask,                                                            \
2017                                                                                                                                    \
2018                                                                   ZCL_CLEAR_PIN_COMMAND_ID, "uu", userId, status);
2019
2020 /** @brief Command description for ClearAllPins
2021  *
2022  * Command: ClearAllPins
2023  * @param status INT8U
2024  */
2025 #define emberAfFillCommandDoor                                                                                                     \
2026     LockClusterClearAllPins(status) emberAfFillExternalBuffer(mask,                                                                \
2027                                                                                                                                    \
2028                                                               ZCL_CLEAR_ALL_PINS_COMMAND_ID, "u", status);
2029
2030 /** @brief Command description for SetUserStatus
2031  *
2032  * Command: SetUserStatus
2033  * @param userId INT16U
2034  * @param status INT8U
2035  * @param userStatus INT8U
2036  */
2037 #define emberAfFillCommandDoor                                                                                                     \
2038     LockClusterSetUserStatus(userId, status, userStatus)                                                                           \
2039         emberAfFillExternalBuffer(mask,                                                                                            \
2040                                                                                                                                    \
2041                                   ZCL_SET_USER_STATUS_COMMAND_ID, "uuu", userId, status, userStatus);
2042
2043 /** @brief Command description for GetUserStatus
2044  *
2045  * Command: GetUserStatus
2046  * @param userId INT16U
2047  * @param userId INT16U
2048  * @param status INT8U
2049  */
2050 #define emberAfFillCommandDoor                                                                                                     \
2051     LockClusterGetUserStatus(userId, userId, status)                                                                               \
2052         emberAfFillExternalBuffer(mask,                                                                                            \
2053                                                                                                                                    \
2054                                   ZCL_GET_USER_STATUS_COMMAND_ID, "uuu", userId, userId, status);
2055
2056 /** @brief Command description for SetWeekdaySchedule
2057  *
2058  * Command: SetWeekdaySchedule
2059  * @param scheduleId INT8U
2060  * @param status INT8U
2061  * @param userId INT16U
2062  * @param daysMask DoorLockDayOfWeek
2063  * @param startHour INT8U
2064  * @param startMinute INT8U
2065  * @param endHour INT8U
2066  * @param endMinute INT8U
2067  */
2068 #define emberAfFillCommandDoor                                                                                                     \
2069     LockClusterSetWeekdaySchedule(scheduleId, status, userId, daysMask, startHour, startMinute, endHour, endMinute)                \
2070         emberAfFillExternalBuffer(mask,                                                                                            \
2071                                                                                                                                    \
2072                                   ZCL_SET_WEEKDAY_SCHEDULE_COMMAND_ID, "uuuuuuuu", scheduleId, status, userId, daysMask,           \
2073                                   startHour, startMinute, endHour, endMinute);
2074
2075 /** @brief Command description for GetWeekdaySchedule
2076  *
2077  * Command: GetWeekdaySchedule
2078  * @param scheduleId INT8U
2079  * @param scheduleId INT8U
2080  * @param userId INT16U
2081  * @param userId INT16U
2082  * @param status INT8U
2083  * @param daysMask INT8U
2084  * @param startHour INT8U
2085  * @param startMinute INT8U
2086  * @param endHour INT8U
2087  * @param endMinute INT8U
2088  */
2089 #define emberAfFillCommandDoor                                                                                                     \
2090     LockClusterGetWeekdaySchedule(scheduleId, scheduleId, userId, userId, status, daysMask, startHour, startMinute, endHour,       \
2091                                   endMinute)                                                                                       \
2092         emberAfFillExternalBuffer(mask,                                                                                            \
2093                                                                                                                                    \
2094                                   ZCL_GET_WEEKDAY_SCHEDULE_COMMAND_ID, "uuuuuuuuuu", scheduleId, scheduleId, userId, userId,       \
2095                                   status, daysMask, startHour, startMinute, endHour, endMinute);
2096
2097 /** @brief Command description for ClearWeekdaySchedule
2098  *
2099  * Command: ClearWeekdaySchedule
2100  * @param scheduleId INT8U
2101  * @param status INT8U
2102  * @param userId INT16U
2103  */
2104 #define emberAfFillCommandDoor                                                                                                     \
2105     LockClusterClearWeekdaySchedule(scheduleId, status, userId)                                                                    \
2106         emberAfFillExternalBuffer(mask,                                                                                            \
2107                                                                                                                                    \
2108                                   ZCL_CLEAR_WEEKDAY_SCHEDULE_COMMAND_ID, "uuu", scheduleId, status, userId);
2109
2110 /** @brief Command description for SetYeardaySchedule
2111  *
2112  * Command: SetYeardaySchedule
2113  * @param scheduleId INT8U
2114  * @param status INT8U
2115  * @param userId INT16U
2116  * @param localStartTime INT32U
2117  * @param localEndTime INT32U
2118  */
2119 #define emberAfFillCommandDoor                                                                                                     \
2120     LockClusterSetYeardaySchedule(scheduleId, status, userId, localStartTime, localEndTime) emberAfFillExternalBuffer(             \
2121         mask,                                                                                                                      \
2122                                                                                                                                    \
2123         ZCL_SET_YEARDAY_SCHEDULE_COMMAND_ID, "uuuuu", scheduleId, status, userId, localStartTime, localEndTime);
2124
2125 /** @brief Command description for GetYeardaySchedule
2126  *
2127  * Command: GetYeardaySchedule
2128  * @param scheduleId INT8U
2129  * @param scheduleId INT8U
2130  * @param userId INT16U
2131  * @param userId INT16U
2132  * @param status INT8U
2133  * @param localStartTime INT32U
2134  * @param localEndTime INT32U
2135  */
2136 #define emberAfFillCommandDoor                                                                                                     \
2137     LockClusterGetYeardaySchedule(scheduleId, scheduleId, userId, userId, status, localStartTime, localEndTime)                    \
2138         emberAfFillExternalBuffer(mask,                                                                                            \
2139                                                                                                                                    \
2140                                   ZCL_GET_YEARDAY_SCHEDULE_COMMAND_ID, "uuuuuuu", scheduleId, scheduleId, userId, userId, status,  \
2141                                   localStartTime, localEndTime);
2142
2143 /** @brief Command description for ClearYeardaySchedule
2144  *
2145  * Command: ClearYeardaySchedule
2146  * @param scheduleId INT8U
2147  * @param status INT8U
2148  * @param userId INT16U
2149  */
2150 #define emberAfFillCommandDoor                                                                                                     \
2151     LockClusterClearYeardaySchedule(scheduleId, status, userId)                                                                    \
2152         emberAfFillExternalBuffer(mask,                                                                                            \
2153                                                                                                                                    \
2154                                   ZCL_CLEAR_YEARDAY_SCHEDULE_COMMAND_ID, "uuu", scheduleId, status, userId);
2155
2156 /** @brief Command description for SetHolidaySchedule
2157  *
2158  * Command: SetHolidaySchedule
2159  * @param scheduleId INT8U
2160  * @param status INT8U
2161  * @param localStartTime INT32U
2162  * @param localEndTime INT32U
2163  * @param operatingModeDuringHoliday ENUM8
2164  */
2165 #define emberAfFillCommandDoor                                                                                                     \
2166     LockClusterSetHolidaySchedule(scheduleId, status, localStartTime, localEndTime, operatingModeDuringHoliday)                    \
2167         emberAfFillExternalBuffer(mask,                                                                                            \
2168                                                                                                                                    \
2169                                   ZCL_SET_HOLIDAY_SCHEDULE_COMMAND_ID, "uuuuu", scheduleId, status, localStartTime, localEndTime,  \
2170                                   operatingModeDuringHoliday);
2171
2172 /** @brief Command description for GetHolidaySchedule
2173  *
2174  * Command: GetHolidaySchedule
2175  * @param scheduleId INT8U
2176  * @param scheduleId INT8U
2177  * @param status INT8U
2178  * @param localStartTime INT32U
2179  * @param localEndTime INT32U
2180  * @param operatingModeDuringHoliday ENUM8
2181  */
2182 #define emberAfFillCommandDoor                                                                                                     \
2183     LockClusterGetHolidaySchedule(scheduleId, scheduleId, status, localStartTime, localEndTime, operatingModeDuringHoliday)        \
2184         emberAfFillExternalBuffer(mask,                                                                                            \
2185                                                                                                                                    \
2186                                   ZCL_GET_HOLIDAY_SCHEDULE_COMMAND_ID, "uuuuuu", scheduleId, scheduleId, status, localStartTime,   \
2187                                   localEndTime, operatingModeDuringHoliday);
2188
2189 /** @brief Command description for ClearHolidaySchedule
2190  *
2191  * Command: ClearHolidaySchedule
2192  * @param scheduleId INT8U
2193  * @param status INT8U
2194  */
2195 #define emberAfFillCommandDoor                                                                                                     \
2196     LockClusterClearHolidaySchedule(scheduleId, status)                                                                            \
2197         emberAfFillExternalBuffer(mask,                                                                                            \
2198                                                                                                                                    \
2199                                   ZCL_CLEAR_HOLIDAY_SCHEDULE_COMMAND_ID, "uu", scheduleId, status);
2200
2201 /** @brief Command description for SetUserType
2202  *
2203  * Command: SetUserType
2204  * @param userId INT16U
2205  * @param status INT8U
2206  * @param userType DoorLockUserType
2207  */
2208 #define emberAfFillCommandDoor                                                                                                     \
2209     LockClusterSetUserType(userId, status, userType)                                                                               \
2210         emberAfFillExternalBuffer(mask,                                                                                            \
2211                                                                                                                                    \
2212                                   ZCL_SET_USER_TYPE_COMMAND_ID, "uuu", userId, status, userType);
2213
2214 /** @brief Command description for GetUserType
2215  *
2216  * Command: GetUserType
2217  * @param userId INT16U
2218  * @param userId INT16U
2219  * @param userType DoorLockUserType
2220  */
2221 #define emberAfFillCommandDoor                                                                                                     \
2222     LockClusterGetUserType(userId, userId, userType)                                                                               \
2223         emberAfFillExternalBuffer(mask,                                                                                            \
2224                                                                                                                                    \
2225                                   ZCL_GET_USER_TYPE_COMMAND_ID, "uuu", userId, userId, userType);
2226
2227 /** @brief Command description for SetRfid
2228  *
2229  * Command: SetRfid
2230  * @param userId INT16U
2231  * @param status DoorLockSetPinOrIdStatus
2232  * @param userStatus DoorLockUserStatus
2233  * @param userType DoorLockUserType
2234  * @param id CHAR_STRING
2235  */
2236 #define emberAfFillCommandDoor                                                                                                     \
2237     LockClusterSetRfid(userId, status, userStatus, userType, id)                                                                   \
2238         emberAfFillExternalBuffer(mask,                                                                                            \
2239                                                                                                                                    \
2240                                   ZCL_SET_RFID_COMMAND_ID, "uuuuu", userId, status, userStatus, userType, id);
2241
2242 /** @brief Command description for GetRfid
2243  *
2244  * Command: GetRfid
2245  * @param userId INT16U
2246  * @param userId INT16U
2247  * @param userStatus DoorLockUserStatus
2248  * @param userType DoorLockUserType
2249  * @param rfid CHAR_STRING
2250  */
2251 #define emberAfFillCommandDoor                                                                                                     \
2252     LockClusterGetRfid(userId, userId, userStatus, userType, rfid)                                                                 \
2253         emberAfFillExternalBuffer(mask,                                                                                            \
2254                                                                                                                                    \
2255                                   ZCL_GET_RFID_COMMAND_ID, "uuuuu", userId, userId, userStatus, userType, rfid);
2256
2257 /** @brief Command description for ClearRfid
2258  *
2259  * Command: ClearRfid
2260  * @param userId INT16U
2261  * @param status INT8U
2262  */
2263 #define emberAfFillCommandDoor                                                                                                     \
2264     LockClusterClearRfid(userId, status) emberAfFillExternalBuffer(mask,                                                           \
2265                                                                                                                                    \
2266                                                                    ZCL_CLEAR_RFID_COMMAND_ID, "uu", userId, status);
2267
2268 /** @brief Command description for ClearAllRfids
2269  *
2270  * Command: ClearAllRfids
2271  * @param status INT8U
2272  */
2273 #define emberAfFillCommandDoor                                                                                                     \
2274     LockClusterClearAllRfids(status) emberAfFillExternalBuffer(mask,                                                               \
2275                                                                                                                                    \
2276                                                                ZCL_CLEAR_ALL_RFIDS_COMMAND_ID, "u", status);
2277
2278 /** @brief Command description for OperationEventNotification
2279  *
2280  * Command: OperationEventNotification
2281  * @param source INT8U
2282  * @param eventCode DoorLockOperationEventCode
2283  * @param userId INT16U
2284  * @param pin CHAR_STRING
2285  * @param timeStamp INT32U
2286  * @param data CHAR_STRING
2287  */
2288 #define emberAfFillCommandDoor                                                                                                     \
2289     LockClusterOperationEventNotification(source, eventCode, userId, pin, timeStamp, data) emberAfFillExternalBuffer(              \
2290         mask,                                                                                                                      \
2291                                                                                                                                    \
2292         ZCL_OPERATION_EVENT_NOTIFICATION_COMMAND_ID, "uuuuuu", source, eventCode, userId, pin, timeStamp, data);
2293
2294 /** @brief Command description for ProgrammingEventNotification
2295  *
2296  * Command: ProgrammingEventNotification
2297  * @param source INT8U
2298  * @param eventCode DoorLockProgrammingEventCode
2299  * @param userId INT16U
2300  * @param pin CHAR_STRING
2301  * @param userType DoorLockUserType
2302  * @param userStatus DoorLockUserStatus
2303  * @param timeStamp INT32U
2304  * @param data CHAR_STRING
2305  */
2306 #define emberAfFillCommandDoor                                                                                                     \
2307     LockClusterProgrammingEventNotification(source, eventCode, userId, pin, userType, userStatus, timeStamp, data)                 \
2308         emberAfFillExternalBuffer(mask,                                                                                            \
2309                                                                                                                                    \
2310                                   ZCL_PROGRAMMING_EVENT_NOTIFICATION_COMMAND_ID, "uuuuuuuu", source, eventCode, userId, pin,       \
2311                                   userType, userStatus, timeStamp, data);
2312
2313 /** @brief Command description for WindowCoveringUpOpen
2314  *
2315  * Command: WindowCoveringUpOpen
2316  */
2317 #define emberAfFillCommandWindow                                                                                                   \
2318     CoveringClusterWindowCoveringUpOpen() emberAfFillExternalBuffer(mask,                                                          \
2319                                                                                                                                    \
2320                                                                     ZCL_WINDOW_COVERING_UP_OPEN_COMMAND_ID, "", );
2321
2322 /** @brief Command description for WindowCoveringDownClose
2323  *
2324  * Command: WindowCoveringDownClose
2325  */
2326 #define emberAfFillCommandWindow                                                                                                   \
2327     CoveringClusterWindowCoveringDownClose() emberAfFillExternalBuffer(mask,                                                       \
2328                                                                                                                                    \
2329                                                                        ZCL_WINDOW_COVERING_DOWN_CLOSE_COMMAND_ID, "", );
2330
2331 /** @brief Command description for WindowCoveringStop
2332  *
2333  * Command: WindowCoveringStop
2334  */
2335 #define emberAfFillCommandWindow                                                                                                   \
2336     CoveringClusterWindowCoveringStop() emberAfFillExternalBuffer(mask,                                                            \
2337                                                                                                                                    \
2338                                                                   ZCL_WINDOW_COVERING_STOP_COMMAND_ID, "", );
2339
2340 /** @brief Command description for WindowCoveringGoToLiftValue
2341  *
2342  * Command: WindowCoveringGoToLiftValue
2343  * @param liftValue INT16U
2344  */
2345 #define emberAfFillCommandWindow                                                                                                   \
2346     CoveringClusterWindowCoveringGoToLiftValue(liftValue)                                                                          \
2347         emberAfFillExternalBuffer(mask,                                                                                            \
2348                                                                                                                                    \
2349                                   ZCL_WINDOW_COVERING_GO_TO_LIFT_VALUE_COMMAND_ID, "u", liftValue);
2350
2351 /** @brief Command description for WindowCoveringGoToLiftPercentage
2352  *
2353  * Command: WindowCoveringGoToLiftPercentage
2354  * @param percentageLiftValue INT8U
2355  */
2356 #define emberAfFillCommandWindow                                                                                                   \
2357     CoveringClusterWindowCoveringGoToLiftPercentage(percentageLiftValue)                                                           \
2358         emberAfFillExternalBuffer(mask,                                                                                            \
2359                                                                                                                                    \
2360                                   ZCL_WINDOW_COVERING_GO_TO_LIFT_PERCENTAGE_COMMAND_ID, "u", percentageLiftValue);
2361
2362 /** @brief Command description for WindowCoveringGoToTiltValue
2363  *
2364  * Command: WindowCoveringGoToTiltValue
2365  * @param tiltValue INT16U
2366  */
2367 #define emberAfFillCommandWindow                                                                                                   \
2368     CoveringClusterWindowCoveringGoToTiltValue(tiltValue)                                                                          \
2369         emberAfFillExternalBuffer(mask,                                                                                            \
2370                                                                                                                                    \
2371                                   ZCL_WINDOW_COVERING_GO_TO_TILT_VALUE_COMMAND_ID, "u", tiltValue);
2372
2373 /** @brief Command description for WindowCoveringGoToTiltPercentage
2374  *
2375  * Command: WindowCoveringGoToTiltPercentage
2376  * @param percentageTiltValue INT8U
2377  */
2378 #define emberAfFillCommandWindow                                                                                                   \
2379     CoveringClusterWindowCoveringGoToTiltPercentage(percentageTiltValue)                                                           \
2380         emberAfFillExternalBuffer(mask,                                                                                            \
2381                                                                                                                                    \
2382                                   ZCL_WINDOW_COVERING_GO_TO_TILT_PERCENTAGE_COMMAND_ID, "u", percentageTiltValue);
2383
2384 /** @brief Command description for BarrierControlGoToPercent
2385  *
2386  * Command: BarrierControlGoToPercent
2387  * @param percentOpen INT8U
2388  */
2389 #define emberAfFillCommandBarrier                                                                                                  \
2390     ControlClusterBarrierControlGoToPercent(percentOpen)                                                                           \
2391         emberAfFillExternalBuffer(mask,                                                                                            \
2392                                                                                                                                    \
2393                                   ZCL_BARRIER_CONTROL_GO_TO_PERCENT_COMMAND_ID, "u", percentOpen);
2394
2395 /** @brief Command description for BarrierControlStop
2396  *
2397  * Command: BarrierControlStop
2398  */
2399 #define emberAfFillCommandBarrier                                                                                                  \
2400     ControlClusterBarrierControlStop() emberAfFillExternalBuffer(mask,                                                             \
2401                                                                                                                                    \
2402                                                                  ZCL_BARRIER_CONTROL_STOP_COMMAND_ID, "", );
2403
2404 /** @brief Command description for SetpointRaiseLower
2405  *
2406  * Command: SetpointRaiseLower
2407  * @param mode SetpointAdjustMode
2408  * @param numberOfTransitionsForSequence ENUM8
2409  * @param amount INT8S
2410  * @param dayOfWeekForSequence DayOfWeek
2411  * @param modeForSequence ModeForSequence
2412  * @param payload INT8U []
2413  * @param payloadLen int
2414  */
2415 #define emberAfFillCommandThermostatClusterSetpointRaiseLower(mode, numberOfTransitionsForSequence, amount, dayOfWeekForSequence,  \
2416                                                               modeForSequence, payload, payloadLen)                                \
2417     emberAfFillExternalBuffer(mask,                                                                                                \
2418                                                                                                                                    \
2419                               ZCL_SETPOINT_RAISE_LOWER_COMMAND_ID, "uuuuub", mode, numberOfTransitionsForSequence, amount,         \
2420                               dayOfWeekForSequence, modeForSequence, payload, payloadLen);
2421
2422 /** @brief Command description for SetWeeklySchedule
2423  *
2424  * Command: SetWeeklySchedule
2425  * @param numberOfTransitionsForSequence ENUM8
2426  * @param timeOfDay INT16U
2427  * @param dayOfWeekForSequence DayOfWeek
2428  * @param relayStatus BITMAP16
2429  * @param modeForSequence ModeForSequence
2430  * @param localTemperature INT16S
2431  * @param payload INT8U []
2432  * @param payloadLen int
2433  * @param humidityInPercentage INT8U
2434  * @param setpoint INT16S
2435  * @param unreadEntries INT16U
2436  */
2437 #define emberAfFillCommandThermostatClusterSetWeeklySchedule(numberOfTransitionsForSequence, timeOfDay, dayOfWeekForSequence,      \
2438                                                              relayStatus, modeForSequence, localTemperature, payload, payloadLen,  \
2439                                                              humidityInPercentage, setpoint, unreadEntries)                        \
2440     emberAfFillExternalBuffer(mask,                                                                                                \
2441                                                                                                                                    \
2442                               ZCL_SET_WEEKLY_SCHEDULE_COMMAND_ID, "uuuuuubuuu", numberOfTransitionsForSequence, timeOfDay,         \
2443                               dayOfWeekForSequence, relayStatus, modeForSequence, localTemperature, payload, payloadLen,           \
2444                               humidityInPercentage, setpoint, unreadEntries);
2445
2446 /** @brief Command description for GetWeeklySchedule
2447  *
2448  * Command: GetWeeklySchedule
2449  * @param daysToReturn DayOfWeek
2450  * @param modeToReturn ModeForSequence
2451  */
2452 #define emberAfFillCommandThermostatClusterGetWeeklySchedule(daysToReturn, modeToReturn)                                           \
2453     emberAfFillExternalBuffer(mask,                                                                                                \
2454                                                                                                                                    \
2455                               ZCL_GET_WEEKLY_SCHEDULE_COMMAND_ID, "uu", daysToReturn, modeToReturn);
2456
2457 /** @brief Command description for ClearWeeklySchedule
2458  *
2459  * Command: ClearWeeklySchedule
2460  */
2461 #define emberAfFillCommandThermostatClusterClearWeeklySchedule()                                                                   \
2462     emberAfFillExternalBuffer(mask,                                                                                                \
2463                                                                                                                                    \
2464                               ZCL_CLEAR_WEEKLY_SCHEDULE_COMMAND_ID, "", );
2465
2466 /** @brief Command description for GetRelayStatusLog
2467  *
2468  * Command: GetRelayStatusLog
2469  */
2470 #define emberAfFillCommandThermostatClusterGetRelayStatusLog()                                                                     \
2471     emberAfFillExternalBuffer(mask,                                                                                                \
2472                                                                                                                                    \
2473                               ZCL_GET_RELAY_STATUS_LOG_COMMAND_ID, "", );
2474
2475 /** @brief Command description for MoveToHue
2476  *
2477  * Command: MoveToHue
2478  * @param hue INT8U
2479  * @param direction HueDirection
2480  * @param transitionTime INT16U
2481  * @param optionsMask BITMAP8
2482  * @param optionsOverride BITMAP8
2483  */
2484 #define emberAfFillCommandColor                                                                                                    \
2485     ControlClusterMoveToHue(hue, direction, transitionTime, optionsMask, optionsOverride) emberAfFillExternalBuffer(               \
2486         mask,                                                                                                                      \
2487                                                                                                                                    \
2488         ZCL_MOVE_TO_HUE_COMMAND_ID, "uuuuu", hue, direction, transitionTime, optionsMask, optionsOverride);
2489
2490 /** @brief Command description for MoveHue
2491  *
2492  * Command: MoveHue
2493  * @param moveMode HueMoveMode
2494  * @param rate INT8U
2495  * @param optionsMask BITMAP8
2496  * @param optionsOverride BITMAP8
2497  */
2498 #define emberAfFillCommandColor                                                                                                    \
2499     ControlClusterMoveHue(moveMode, rate, optionsMask, optionsOverride)                                                            \
2500         emberAfFillExternalBuffer(mask,                                                                                            \
2501                                                                                                                                    \
2502                                   ZCL_MOVE_HUE_COMMAND_ID, "uuuu", moveMode, rate, optionsMask, optionsOverride);
2503
2504 /** @brief Command description for StepHue
2505  *
2506  * Command: StepHue
2507  * @param stepMode HueStepMode
2508  * @param stepSize INT8U
2509  * @param transitionTime INT8U
2510  * @param optionsMask BITMAP8
2511  * @param optionsOverride BITMAP8
2512  */
2513 #define emberAfFillCommandColor                                                                                                    \
2514     ControlClusterStepHue(stepMode, stepSize, transitionTime, optionsMask, optionsOverride) emberAfFillExternalBuffer(             \
2515         mask,                                                                                                                      \
2516                                                                                                                                    \
2517         ZCL_STEP_HUE_COMMAND_ID, "uuuuu", stepMode, stepSize, transitionTime, optionsMask, optionsOverride);
2518
2519 /** @brief Command description for MoveToSaturation
2520  *
2521  * Command: MoveToSaturation
2522  * @param saturation INT8U
2523  * @param transitionTime INT16U
2524  * @param optionsMask BITMAP8
2525  * @param optionsOverride BITMAP8
2526  */
2527 #define emberAfFillCommandColor                                                                                                    \
2528     ControlClusterMoveToSaturation(saturation, transitionTime, optionsMask, optionsOverride) emberAfFillExternalBuffer(            \
2529         mask,                                                                                                                      \
2530                                                                                                                                    \
2531         ZCL_MOVE_TO_SATURATION_COMMAND_ID, "uuuu", saturation, transitionTime, optionsMask, optionsOverride);
2532
2533 /** @brief Command description for MoveSaturation
2534  *
2535  * Command: MoveSaturation
2536  * @param moveMode SaturationMoveMode
2537  * @param rate INT8U
2538  * @param optionsMask BITMAP8
2539  * @param optionsOverride BITMAP8
2540  */
2541 #define emberAfFillCommandColor                                                                                                    \
2542     ControlClusterMoveSaturation(moveMode, rate, optionsMask, optionsOverride)                                                     \
2543         emberAfFillExternalBuffer(mask,                                                                                            \
2544                                                                                                                                    \
2545                                   ZCL_MOVE_SATURATION_COMMAND_ID, "uuuu", moveMode, rate, optionsMask, optionsOverride);
2546
2547 /** @brief Command description for StepSaturation
2548  *
2549  * Command: StepSaturation
2550  * @param stepMode SaturationStepMode
2551  * @param stepSize INT8U
2552  * @param transitionTime INT8U
2553  * @param optionsMask BITMAP8
2554  * @param optionsOverride BITMAP8
2555  */
2556 #define emberAfFillCommandColor                                                                                                    \
2557     ControlClusterStepSaturation(stepMode, stepSize, transitionTime, optionsMask, optionsOverride) emberAfFillExternalBuffer(      \
2558         mask,                                                                                                                      \
2559                                                                                                                                    \
2560         ZCL_STEP_SATURATION_COMMAND_ID, "uuuuu", stepMode, stepSize, transitionTime, optionsMask, optionsOverride);
2561
2562 /** @brief Command description for MoveToHueAndSaturation
2563  *
2564  * Command: MoveToHueAndSaturation
2565  * @param hue INT8U
2566  * @param saturation INT8U
2567  * @param transitionTime INT16U
2568  * @param optionsMask BITMAP8
2569  * @param optionsOverride BITMAP8
2570  */
2571 #define emberAfFillCommandColor                                                                                                    \
2572     ControlClusterMoveToHueAndSaturation(hue, saturation, transitionTime, optionsMask, optionsOverride) emberAfFillExternalBuffer( \
2573         mask,                                                                                                                      \
2574                                                                                                                                    \
2575         ZCL_MOVE_TO_HUE_AND_SATURATION_COMMAND_ID, "uuuuu", hue, saturation, transitionTime, optionsMask, optionsOverride);
2576
2577 /** @brief Command description for MoveToColor
2578  *
2579  * Command: MoveToColor
2580  * @param colorX INT16U
2581  * @param colorY INT16U
2582  * @param transitionTime INT16U
2583  * @param optionsMask BITMAP8
2584  * @param optionsOverride BITMAP8
2585  */
2586 #define emberAfFillCommandColor                                                                                                    \
2587     ControlClusterMoveToColor(colorX, colorY, transitionTime, optionsMask, optionsOverride) emberAfFillExternalBuffer(             \
2588         mask,                                                                                                                      \
2589                                                                                                                                    \
2590         ZCL_MOVE_TO_COLOR_COMMAND_ID, "uuuuu", colorX, colorY, transitionTime, optionsMask, optionsOverride);
2591
2592 /** @brief Command description for MoveColor
2593  *
2594  * Command: MoveColor
2595  * @param rateX INT16S
2596  * @param rateY INT16S
2597  * @param optionsMask BITMAP8
2598  * @param optionsOverride BITMAP8
2599  */
2600 #define emberAfFillCommandColor                                                                                                    \
2601     ControlClusterMoveColor(rateX, rateY, optionsMask, optionsOverride)                                                            \
2602         emberAfFillExternalBuffer(mask,                                                                                            \
2603                                                                                                                                    \
2604                                   ZCL_MOVE_COLOR_COMMAND_ID, "uuuu", rateX, rateY, optionsMask, optionsOverride);
2605
2606 /** @brief Command description for StepColor
2607  *
2608  * Command: StepColor
2609  * @param stepX INT16S
2610  * @param stepY INT16S
2611  * @param transitionTime INT16U
2612  * @param optionsMask BITMAP8
2613  * @param optionsOverride BITMAP8
2614  */
2615 #define emberAfFillCommandColor                                                                                                    \
2616     ControlClusterStepColor(stepX, stepY, transitionTime, optionsMask, optionsOverride)                                            \
2617         emberAfFillExternalBuffer(mask,                                                                                            \
2618                                                                                                                                    \
2619                                   ZCL_STEP_COLOR_COMMAND_ID, "uuuuu", stepX, stepY, transitionTime, optionsMask, optionsOverride);
2620
2621 /** @brief Command description for MoveToColorTemperature
2622  *
2623  * Command: MoveToColorTemperature
2624  * @param colorTemperature INT16U
2625  * @param transitionTime INT16U
2626  * @param optionsMask BITMAP8
2627  * @param optionsOverride BITMAP8
2628  */
2629 #define emberAfFillCommandColor                                                                                                    \
2630     ControlClusterMoveToColorTemperature(colorTemperature, transitionTime, optionsMask, optionsOverride)                           \
2631         emberAfFillExternalBuffer(mask,                                                                                            \
2632                                                                                                                                    \
2633                                   ZCL_MOVE_TO_COLOR_TEMPERATURE_COMMAND_ID, "uuuu", colorTemperature, transitionTime, optionsMask, \
2634                                   optionsOverride);
2635
2636 /** @brief Command description for EnhancedMoveToHue
2637  *
2638  * Command: EnhancedMoveToHue
2639  * @param enhancedHue INT16U
2640  * @param direction HueDirection
2641  * @param transitionTime INT16U
2642  */
2643 #define emberAfFillCommandColor                                                                                                    \
2644     ControlClusterEnhancedMoveToHue(enhancedHue, direction, transitionTime)                                                        \
2645         emberAfFillExternalBuffer(mask,                                                                                            \
2646                                                                                                                                    \
2647                                   ZCL_ENHANCED_MOVE_TO_HUE_COMMAND_ID, "uuu", enhancedHue, direction, transitionTime);
2648
2649 /** @brief Command description for EnhancedMoveHue
2650  *
2651  * Command: EnhancedMoveHue
2652  * @param moveMode HueMoveMode
2653  * @param rate INT16U
2654  */
2655 #define emberAfFillCommandColor                                                                                                    \
2656     ControlClusterEnhancedMoveHue(moveMode, rate)                                                                                  \
2657         emberAfFillExternalBuffer(mask,                                                                                            \
2658                                                                                                                                    \
2659                                   ZCL_ENHANCED_MOVE_HUE_COMMAND_ID, "uu", moveMode, rate);
2660
2661 /** @brief Command description for EnhancedStepHue
2662  *
2663  * Command: EnhancedStepHue
2664  * @param stepMode HueStepMode
2665  * @param stepSize INT16U
2666  * @param transitionTime INT16U
2667  */
2668 #define emberAfFillCommandColor                                                                                                    \
2669     ControlClusterEnhancedStepHue(stepMode, stepSize, transitionTime)                                                              \
2670         emberAfFillExternalBuffer(mask,                                                                                            \
2671                                                                                                                                    \
2672                                   ZCL_ENHANCED_STEP_HUE_COMMAND_ID, "uuu", stepMode, stepSize, transitionTime);
2673
2674 /** @brief Command description for EnhancedMoveToHueAndSaturation
2675  *
2676  * Command: EnhancedMoveToHueAndSaturation
2677  * @param enhancedHue INT16U
2678  * @param saturation INT8U
2679  * @param transitionTime INT16U
2680  */
2681 #define emberAfFillCommandColor                                                                                                    \
2682     ControlClusterEnhancedMoveToHueAndSaturation(enhancedHue, saturation, transitionTime) emberAfFillExternalBuffer(               \
2683         mask,                                                                                                                      \
2684                                                                                                                                    \
2685         ZCL_ENHANCED_MOVE_TO_HUE_AND_SATURATION_COMMAND_ID, "uuu", enhancedHue, saturation, transitionTime);
2686
2687 /** @brief Command description for ColorLoopSet
2688  *
2689  * Command: ColorLoopSet
2690  * @param updateFlags ColorLoopUpdateFlags
2691  * @param action ColorLoopAction
2692  * @param direction ColorLoopDirection
2693  * @param time INT16U
2694  * @param startHue INT16U
2695  */
2696 #define emberAfFillCommandColor                                                                                                    \
2697     ControlClusterColorLoopSet(updateFlags, action, direction, time, startHue)                                                     \
2698         emberAfFillExternalBuffer(mask,                                                                                            \
2699                                                                                                                                    \
2700                                   ZCL_COLOR_LOOP_SET_COMMAND_ID, "uuuuu", updateFlags, action, direction, time, startHue);
2701
2702 /** @brief Command description for StopMoveStep
2703  *
2704  * Command: StopMoveStep
2705  * @param optionsMask BITMAP8
2706  * @param optionsOverride BITMAP8
2707  */
2708 #define emberAfFillCommandColor                                                                                                    \
2709     ControlClusterStopMoveStep(optionsMask, optionsOverride)                                                                       \
2710         emberAfFillExternalBuffer(mask,                                                                                            \
2711                                                                                                                                    \
2712                                   ZCL_STOP_MOVE_STEP_COMMAND_ID, "uu", optionsMask, optionsOverride);
2713
2714 /** @brief Command description for MoveColorTemperature
2715  *
2716  * Command: MoveColorTemperature
2717  * @param moveMode HueMoveMode
2718  * @param rate INT16U
2719  * @param colorTemperatureMinimum INT16U
2720  * @param colorTemperatureMaximum INT16U
2721  * @param optionsMask BITMAP8
2722  * @param optionsOverride BITMAP8
2723  */
2724 #define emberAfFillCommandColor                                                                                                    \
2725     ControlClusterMoveColorTemperature(moveMode, rate, colorTemperatureMinimum, colorTemperatureMaximum, optionsMask,              \
2726                                        optionsOverride)                                                                            \
2727         emberAfFillExternalBuffer(mask,                                                                                            \
2728                                                                                                                                    \
2729                                   ZCL_MOVE_COLOR_TEMPERATURE_COMMAND_ID, "uuuuuu", moveMode, rate, colorTemperatureMinimum,        \
2730                                   colorTemperatureMaximum, optionsMask, optionsOverride);
2731
2732 /** @brief Command description for StepColorTemperature
2733  *
2734  * Command: StepColorTemperature
2735  * @param stepMode HueStepMode
2736  * @param stepSize INT16U
2737  * @param transitionTime INT16U
2738  * @param colorTemperatureMinimum INT16U
2739  * @param colorTemperatureMaximum INT16U
2740  * @param optionsMask BITMAP8
2741  * @param optionsOverride BITMAP8
2742  */
2743 #define emberAfFillCommandColor                                                                                                    \
2744     ControlClusterStepColorTemperature(stepMode, stepSize, transitionTime, colorTemperatureMinimum, colorTemperatureMaximum,       \
2745                                        optionsMask, optionsOverride)                                                               \
2746         emberAfFillExternalBuffer(mask,                                                                                            \
2747                                                                                                                                    \
2748                                   ZCL_STEP_COLOR_TEMPERATURE_COMMAND_ID, "uuuuuuu", stepMode, stepSize, transitionTime,            \
2749                                   colorTemperatureMinimum, colorTemperatureMaximum, optionsMask, optionsOverride);
2750
2751 /** @brief Command description for ZoneEnrollResponse
2752  *
2753  * Command: ZoneEnrollResponse
2754  * @param enrollResponseCode IasEnrollResponseCode
2755  * @param zoneStatus IasZoneStatus
2756  * @param zoneId INT8U
2757  * @param extendedStatus BITMAP8
2758  * @param zoneId INT8U
2759  * @param delay INT16U
2760  */
2761 #define emberAfFillCommandIAS                                                                                                      \
2762     ZoneClusterZoneEnrollResponse(enrollResponseCode, zoneStatus, zoneId, extendedStatus, zoneId, delay)                           \
2763         emberAfFillExternalBuffer(mask,                                                                                            \
2764                                                                                                                                    \
2765                                   ZCL_ZONE_ENROLL_RESPONSE_COMMAND_ID, "uuuuuu", enrollResponseCode, zoneStatus, zoneId,           \
2766                                   extendedStatus, zoneId, delay);
2767
2768 /** @brief Command description for InitiateNormalOperationMode
2769  *
2770  * Command: InitiateNormalOperationMode
2771  * @param zoneType IasZoneType
2772  * @param manufacturerCode INT16U
2773  */
2774 #define emberAfFillCommandIAS                                                                                                      \
2775     ZoneClusterInitiateNormalOperationMode(zoneType, manufacturerCode)                                                             \
2776         emberAfFillExternalBuffer(mask,                                                                                            \
2777                                                                                                                                    \
2778                                   ZCL_INITIATE_NORMAL_OPERATION_MODE_COMMAND_ID, "uu", zoneType, manufacturerCode);
2779
2780 /** @brief Command description for InitiateNormalOperationModeResponse
2781  *
2782  * Command: InitiateNormalOperationModeResponse
2783  * @param testModeDuration INT8U
2784  * @param currentZoneSensitivityLevel INT8U
2785  */
2786 #define emberAfFillCommandIAS                                                                                                      \
2787     ZoneClusterInitiateNormalOperationModeResponse(testModeDuration, currentZoneSensitivityLevel) emberAfFillExternalBuffer(       \
2788         mask,                                                                                                                      \
2789                                                                                                                                    \
2790         ZCL_INITIATE_NORMAL_OPERATION_MODE_RESPONSE_COMMAND_ID, "uu", testModeDuration, currentZoneSensitivityLevel);
2791
2792 /** @brief Command description for InitiateTestModeResponse
2793  *
2794  * Command: InitiateTestModeResponse
2795  */
2796 #define emberAfFillCommandIAS                                                                                                      \
2797     ZoneClusterInitiateTestModeResponse() emberAfFillExternalBuffer(mask,                                                          \
2798                                                                                                                                    \
2799                                                                     ZCL_INITIATE_TEST_MODE_RESPONSE_COMMAND_ID, "", );
2800
2801 /** @brief Command description for Arm
2802  *
2803  * Command: Arm
2804  * @param armMode IasAceArmMode
2805  * @param armNotification IasAceArmNotification
2806  * @param armDisarmCode CHAR_STRING
2807  * @param zoneId INT8U
2808  */
2809 #define emberAfFillCommandIAS                                                                                                      \
2810     ACEClusterArm(armMode, armNotification, armDisarmCode, zoneId)                                                                 \
2811         emberAfFillExternalBuffer(mask,                                                                                            \
2812                                                                                                                                    \
2813                                   ZCL_ARM_COMMAND_ID, "uuuu", armMode, armNotification, armDisarmCode, zoneId);
2814
2815 /** @brief Command description for Bypass
2816  *
2817  * Command: Bypass
2818  * @param numberOfZones INT8U
2819  * @param section0 BITMAP16
2820  * @param zoneIds INT8U []
2821  * @param zoneIdsLen int
2822  * @param section1 BITMAP16
2823  * @param armDisarmCode CHAR_STRING
2824  * @param section2 BITMAP16
2825  * @param section3 BITMAP16
2826  * @param section4 BITMAP16
2827  * @param section5 BITMAP16
2828  * @param section6 BITMAP16
2829  * @param section7 BITMAP16
2830  * @param section8 BITMAP16
2831  * @param section9 BITMAP16
2832  * @param section10 BITMAP16
2833  * @param section11 BITMAP16
2834  * @param section12 BITMAP16
2835  * @param section13 BITMAP16
2836  * @param section14 BITMAP16
2837  * @param section15 BITMAP16
2838  */
2839 #define emberAfFillCommandIAS                                                                                                      \
2840     ACEClusterBypass(numberOfZones, section0, zoneIds, zoneIdsLen, section1, armDisarmCode, section2, section3, section4,          \
2841                      section5, section6, section7, section8, section9, section10, section11, section12, section13, section14,      \
2842                      section15)                                                                                                    \
2843         emberAfFillExternalBuffer(mask,                                                                                            \
2844                                                                                                                                    \
2845                                   ZCL_BYPASS_COMMAND_ID, "uubuuuuuuuuuuuuuuuu", numberOfZones, section0, zoneIds, zoneIdsLen,      \
2846                                   section1, armDisarmCode, section2, section3, section4, section5, section6, section7, section8,   \
2847                                   section9, section10, section11, section12, section13, section14, section15);
2848
2849 /** @brief Command description for Emergency
2850  *
2851  * Command: Emergency
2852  * @param zoneId INT8U
2853  * @param zoneType IasZoneType
2854  * @param ieeeAddress IEEE_ADDRESS
2855  * @param zoneLabel CHAR_STRING
2856  */
2857 #define emberAfFillCommandIAS                                                                                                      \
2858     ACEClusterEmergency(zoneId, zoneType, ieeeAddress, zoneLabel)                                                                  \
2859         emberAfFillExternalBuffer(mask,                                                                                            \
2860                                                                                                                                    \
2861                                   ZCL_EMERGENCY_COMMAND_ID, "uuuu", zoneId, zoneType, ieeeAddress, zoneLabel);
2862
2863 /** @brief Command description for Fire
2864  *
2865  * Command: Fire
2866  * @param zoneId INT8U
2867  * @param zoneStatus ENUM16
2868  * @param audibleNotification IasAceAudibleNotification
2869  * @param zoneLabel CHAR_STRING
2870  */
2871 #define emberAfFillCommandIAS                                                                                                      \
2872     ACEClusterFire(zoneId, zoneStatus, audibleNotification, zoneLabel)                                                             \
2873         emberAfFillExternalBuffer(mask,                                                                                            \
2874                                                                                                                                    \
2875                                   ZCL_FIRE_COMMAND_ID, "uuuu", zoneId, zoneStatus, audibleNotification, zoneLabel);
2876
2877 /** @brief Command description for Panic
2878  *
2879  * Command: Panic
2880  * @param panelStatus IasAcePanelStatus
2881  * @param secondsRemaining INT8U
2882  * @param audibleNotification IasAceAudibleNotification
2883  * @param alarmStatus IasAceAlarmStatus
2884  */
2885 #define emberAfFillCommandIAS                                                                                                      \
2886     ACEClusterPanic(panelStatus, secondsRemaining, audibleNotification, alarmStatus)                                               \
2887         emberAfFillExternalBuffer(mask,                                                                                            \
2888                                                                                                                                    \
2889                                   ZCL_PANIC_COMMAND_ID, "uuuu", panelStatus, secondsRemaining, audibleNotification, alarmStatus);
2890
2891 /** @brief Command description for GetZoneIdMap
2892  *
2893  * Command: GetZoneIdMap
2894  * @param panelStatus IasAcePanelStatus
2895  * @param secondsRemaining INT8U
2896  * @param audibleNotification IasAceAudibleNotification
2897  * @param alarmStatus IasAceAlarmStatus
2898  */
2899 #define emberAfFillCommandIAS                                                                                                      \
2900     ACEClusterGetZoneIdMap(panelStatus, secondsRemaining, audibleNotification, alarmStatus) emberAfFillExternalBuffer(             \
2901         mask,                                                                                                                      \
2902                                                                                                                                    \
2903         ZCL_GET_ZONE_ID_MAP_COMMAND_ID, "uuuu", panelStatus, secondsRemaining, audibleNotification, alarmStatus);
2904
2905 /** @brief Command description for GetZoneInformation
2906  *
2907  * Command: GetZoneInformation
2908  * @param zoneId INT8U
2909  * @param numberOfZones INT8U
2910  * @param zoneIds INT8U []
2911  * @param zoneIdsLen int
2912  */
2913 #define emberAfFillCommandIAS                                                                                                      \
2914     ACEClusterGetZoneInformation(zoneId, numberOfZones, zoneIds, zoneIdsLen)                                                       \
2915         emberAfFillExternalBuffer(mask,                                                                                            \
2916                                                                                                                                    \
2917                                   ZCL_GET_ZONE_INFORMATION_COMMAND_ID, "uub", zoneId, numberOfZones, zoneIds, zoneIdsLen);
2918
2919 /** @brief Command description for GetPanelStatus
2920  *
2921  * Command: GetPanelStatus
2922  * @param numberOfZones INT8U
2923  * @param bypassResult IasAceBypassResult []
2924  * @param bypassResultLen int
2925  */
2926 #define emberAfFillCommandIAS                                                                                                      \
2927     ACEClusterGetPanelStatus(numberOfZones, bypassResult, bypassResultLen)                                                         \
2928         emberAfFillExternalBuffer(mask,                                                                                            \
2929                                                                                                                                    \
2930                                   ZCL_GET_PANEL_STATUS_COMMAND_ID, "ub", numberOfZones, bypassResult, bypassResultLen);
2931
2932 /** @brief Command description for GetBypassedZoneList
2933  *
2934  * Command: GetBypassedZoneList
2935  * @param zoneStatusComplete BOOLEAN
2936  * @param numberOfZones INT8U
2937  * @param zoneStatusResult IasAceZoneStatusResult []
2938  * @param zoneStatusResultLen int
2939  */
2940 #define emberAfFillCommandIAS                                                                                                      \
2941     ACEClusterGetBypassedZoneList(zoneStatusComplete, numberOfZones, zoneStatusResult, zoneStatusResultLen)                        \
2942         emberAfFillExternalBuffer(mask,                                                                                            \
2943                                                                                                                                    \
2944                                   ZCL_GET_BYPASSED_ZONE_LIST_COMMAND_ID, "uub", zoneStatusComplete, numberOfZones,                 \
2945                                   zoneStatusResult, zoneStatusResultLen);
2946
2947 /** @brief Command description for GetZoneStatus
2948  *
2949  * Command: GetZoneStatus
2950  * @param startingZoneId INT8U
2951  * @param maxNumberOfZoneIds INT8U
2952  * @param zoneStatusMaskFlag BOOLEAN
2953  * @param zoneStatusMask BITMAP16
2954  */
2955 #define emberAfFillCommandIAS                                                                                                      \
2956     ACEClusterGetZoneStatus(startingZoneId, maxNumberOfZoneIds, zoneStatusMaskFlag, zoneStatusMask) emberAfFillExternalBuffer(     \
2957         mask,                                                                                                                      \
2958                                                                                                                                    \
2959         ZCL_GET_ZONE_STATUS_COMMAND_ID, "uuuu", startingZoneId, maxNumberOfZoneIds, zoneStatusMaskFlag, zoneStatusMask);
2960
2961 /** @brief Command description for StartWarning
2962  *
2963  * Command: StartWarning
2964  * @param warningInfo WarningInfo
2965  * @param warningDuration INT16U
2966  * @param strobeDutyCycle INT8U
2967  * @param strobeLevel ENUM8
2968  */
2969 #define emberAfFillCommandIAS                                                                                                      \
2970     WDClusterStartWarning(warningInfo, warningDuration, strobeDutyCycle, strobeLevel) emberAfFillExternalBuffer(                   \
2971         mask,                                                                                                                      \
2972                                                                                                                                    \
2973         ZCL_START_WARNING_COMMAND_ID, "uuuu", warningInfo, warningDuration, strobeDutyCycle, strobeLevel);
2974
2975 /** @brief Command description for Squawk
2976  *
2977  * Command: Squawk
2978  * @param squawkInfo SquawkInfo
2979  */
2980 #define emberAfFillCommandIAS                                                                                                      \
2981     WDClusterSquawk(squawkInfo) emberAfFillExternalBuffer(mask,                                                                    \
2982                                                                                                                                    \
2983                                                           ZCL_SQUAWK_COMMAND_ID, "u", squawkInfo);
2984
2985 /** @brief Command description for Sleep
2986  *
2987  * Command: Sleep
2988  */
2989 #define emberAfFillCommandLow                                                                                                      \
2990     PowerClusterSleep() emberAfFillExternalBuffer(mask,                                                                            \
2991                                                                                                                                    \
2992                                                   ZCL_SLEEP_COMMAND_ID, "", );
2993
2994 /** @brief Command description for MatchProtocolAddress
2995  *
2996  * Command: MatchProtocolAddress
2997  * @param protocolAddress OCTET_STRING
2998  * @param deviceIeeeAddress IEEE_ADDRESS
2999  * @param protocolAddress OCTET_STRING
3000  */
3001 #define emberAfFillCommandGeneric                                                                                                  \
3002     TunnelClusterMatchProtocolAddress(protocolAddress, deviceIeeeAddress, protocolAddress) emberAfFillExternalBuffer(              \
3003         mask,                                                                                                                      \
3004                                                                                                                                    \
3005         ZCL_MATCH_PROTOCOL_ADDRESS_COMMAND_ID, "uuu", protocolAddress, deviceIeeeAddress, protocolAddress);
3006
3007 /** @brief Command description for AdvertiseProtocolAddress
3008  *
3009  * Command: AdvertiseProtocolAddress
3010  * @param protocolAddress OCTET_STRING
3011  */
3012 #define emberAfFillCommandGeneric                                                                                                  \
3013     TunnelClusterAdvertiseProtocolAddress(protocolAddress)                                                                         \
3014         emberAfFillExternalBuffer(mask,                                                                                            \
3015                                                                                                                                    \
3016                                   ZCL_ADVERTISE_PROTOCOL_ADDRESS_COMMAND_ID, "u", protocolAddress);
3017
3018 /** @brief Command description for TransferNpdu
3019  *
3020  * Command: TransferNpdu
3021  * @param npdu DATA8 []
3022  * @param npduLen int
3023  */
3024 #define emberAfFillCommandBACnet                                                                                                   \
3025     Protocol TunnelClusterTransferNpdu(npdu, npduLen) emberAfFillExternalBuffer(mask,                                              \
3026                                                                                                                                    \
3027                                                                                 ZCL_TRANSFER_NPDU_COMMAND_ID, "b", npdu, npduLen);
3028
3029 /** @brief Command description for TransferAPDU
3030  *
3031  * Command: TransferAPDU
3032  * @param apdu OCTET_STRING
3033  */
3034 #define emberAfFillCommand11073                                                                                                    \
3035     Protocol TunnelClusterTransferAPDU(apdu) emberAfFillExternalBuffer(mask,                                                       \
3036                                                                                                                                    \
3037                                                                        ZCL_TRANSFER_APDU_COMMAND_ID, "u", apdu);
3038
3039 /** @brief Command description for ConnectRequest
3040  *
3041  * Command: ConnectRequest
3042  * @param connectControl 11073ConnectRequestConnectControl
3043  * @param idleTimeout INT16U
3044  * @param managerTarget IEEE_ADDRESS
3045  * @param managerEndpoint INT8U
3046  */
3047 #define emberAfFillCommand11073                                                                                                    \
3048     Protocol TunnelClusterConnectRequest(connectControl, idleTimeout, managerTarget, managerEndpoint) emberAfFillExternalBuffer(   \
3049         mask,                                                                                                                      \
3050                                                                                                                                    \
3051         ZCL_CONNECT_REQUEST_COMMAND_ID, "uuuu", connectControl, idleTimeout, managerTarget, managerEndpoint);
3052
3053 /** @brief Command description for DisconnectRequest
3054  *
3055  * Command: DisconnectRequest
3056  * @param managerIEEEAddress IEEE_ADDRESS
3057  */
3058 #define emberAfFillCommand11073                                                                                                    \
3059     Protocol TunnelClusterDisconnectRequest(managerIEEEAddress)                                                                    \
3060         emberAfFillExternalBuffer(mask,                                                                                            \
3061                                                                                                                                    \
3062                                   ZCL_DISCONNECT_REQUEST_COMMAND_ID, "u", managerIEEEAddress);
3063
3064 /** @brief Command description for ConnectStatusNotification
3065  *
3066  * Command: ConnectStatusNotification
3067  * @param connectStatus 11073TunnelConnectionStatus
3068  */
3069 #define emberAfFillCommand11073                                                                                                    \
3070     Protocol TunnelClusterConnectStatusNotification(connectStatus)                                                                 \
3071         emberAfFillExternalBuffer(mask,                                                                                            \
3072                                                                                                                                    \
3073                                   ZCL_CONNECT_STATUS_NOTIFICATION_COMMAND_ID, "u", connectStatus);
3074
3075 /** @brief Command description for TransferApdu
3076  *
3077  * Command: TransferApdu
3078  * @param apdu OCTET_STRING
3079  */
3080 #define emberAfFillCommandISO                                                                                                      \
3081     7816 Protocol TunnelClusterTransferApdu(apdu) emberAfFillExternalBuffer(mask,                                                  \
3082                                                                                                                                    \
3083                                                                             ZCL_TRANSFER_APDU_COMMAND_ID, "u", apdu);
3084
3085 /** @brief Command description for InsertSmartCard
3086  *
3087  * Command: InsertSmartCard
3088  */
3089 #define emberAfFillCommandISO                                                                                                      \
3090     7816 Protocol TunnelClusterInsertSmartCard() emberAfFillExternalBuffer(mask,                                                   \
3091                                                                                                                                    \
3092                                                                            ZCL_INSERT_SMART_CARD_COMMAND_ID, "", );
3093
3094 /** @brief Command description for ExtractSmartCard
3095  *
3096  * Command: ExtractSmartCard
3097  */
3098 #define emberAfFillCommandISO                                                                                                      \
3099     7816 Protocol TunnelClusterExtractSmartCard() emberAfFillExternalBuffer(mask,                                                  \
3100                                                                                                                                    \
3101                                                                             ZCL_EXTRACT_SMART_CARD_COMMAND_ID, "", );
3102
3103 /** @brief Command description for PublishPrice
3104  *
3105  * Command: PublishPrice
3106  * @param providerId INT32U
3107  * @param commandOptions AmiCommandOptions
3108  * @param rateLabel OCTET_STRING
3109  * @param issuerEventId INT32U
3110  * @param currentTime UTC_TIME
3111  * @param unitOfMeasure AmiUnitOfMeasure
3112  * @param currency INT16U
3113  * @param priceTrailingDigitAndPriceTier PriceTrailingDigitAndPriceTier
3114  * @param numberOfPriceTiersAndRegisterTier PriceNumberOfPriceTiersAndRegisterTier
3115  * @param startTime UTC_TIME
3116  * @param durationInMinutes INT16U
3117  * @param price INT32U
3118  * @param priceRatio INT8U
3119  * @param generationPrice INT32U
3120  * @param generationPriceRatio INT8U
3121  * @param alternateCostDelivered INT32U
3122  * @param alternateCostUnit AlternateCostUnit
3123  * @param alternateCostTrailingDigit AlternateCostTrailingDigit
3124  * @param numberOfBlockThresholds INT8U
3125  * @param priceControl PriceControlMask
3126  * @param numberOfGenerationTiers INT8U
3127  * @param generationTier GenerationTier
3128  * @param extendedNumberOfPriceTiers ExtendedNumberOfPriceTiers
3129  * @param extendedPriceTier ExtendedPriceTier
3130  * @param extendedRegisterTier ExtendedRegisterTier
3131  */
3132 #define emberAfFillCommandPriceClusterPublishPrice(                                                                                \
3133     providerId, commandOptions, rateLabel, issuerEventId, currentTime, unitOfMeasure, currency, priceTrailingDigitAndPriceTier,    \
3134     numberOfPriceTiersAndRegisterTier, startTime, durationInMinutes, price, priceRatio, generationPrice, generationPriceRatio,     \
3135     alternateCostDelivered, alternateCostUnit, alternateCostTrailingDigit, numberOfBlockThresholds, priceControl,                  \
3136     numberOfGenerationTiers, generationTier, extendedNumberOfPriceTiers, extendedPriceTier, extendedRegisterTier)                  \
3137     emberAfFillExternalBuffer(mask,                                                                                                \
3138                                                                                                                                    \
3139                               ZCL_PUBLISH_PRICE_COMMAND_ID, "uuuuuuuuuuuuuuuuuuuuuuuuu", providerId, commandOptions, rateLabel,    \
3140                               issuerEventId, currentTime, unitOfMeasure, currency, priceTrailingDigitAndPriceTier,                 \
3141                               numberOfPriceTiersAndRegisterTier, startTime, durationInMinutes, price, priceRatio, generationPrice, \
3142                               generationPriceRatio, alternateCostDelivered, alternateCostUnit, alternateCostTrailingDigit,         \
3143                               numberOfBlockThresholds, priceControl, numberOfGenerationTiers, generationTier,                      \
3144                               extendedNumberOfPriceTiers, extendedPriceTier, extendedRegisterTier);
3145
3146 /** @brief Command description for PublishBlockPeriod
3147  *
3148  * Command: PublishBlockPeriod
3149  * @param providerId INT32U
3150  * @param startTime UTC_TIME
3151  * @param issuerEventId INT32U
3152  * @param numberOfEvents INT8U
3153  * @param blockPeriodStartTime UTC_TIME
3154  * @param blockPeriodDuration INT24U
3155  * @param blockPeriodControl BlockPeriodControl
3156  * @param blockPeriodDurationType BlockPeriodDurationType
3157  * @param tariffType TariffType
3158  * @param tariffResolutionPeriod TariffResolutionPeriod
3159  */
3160 #define emberAfFillCommandPriceClusterPublishBlockPeriod(providerId, startTime, issuerEventId, numberOfEvents,                     \
3161                                                          blockPeriodStartTime, blockPeriodDuration, blockPeriodControl,            \
3162                                                          blockPeriodDurationType, tariffType, tariffResolutionPeriod)              \
3163     emberAfFillExternalBuffer(mask,                                                                                                \
3164                                                                                                                                    \
3165                               ZCL_PUBLISH_BLOCK_PERIOD_COMMAND_ID, "uuuuuuuuuu", providerId, startTime, issuerEventId,             \
3166                               numberOfEvents, blockPeriodStartTime, blockPeriodDuration, blockPeriodControl,                       \
3167                               blockPeriodDurationType, tariffType, tariffResolutionPeriod);
3168
3169 /** @brief Command description for PublishConversionFactor
3170  *
3171  * Command: PublishConversionFactor
3172  * @param issuerEventId INT32U
3173  * @param providerId INT32U
3174  * @param startTime UTC_TIME
3175  * @param issuerEventId INT32U
3176  * @param conversionFactor INT32U
3177  * @param priceAckTime UTC_TIME
3178  * @param conversionFactorTrailingDigit ConversionFactorTrailingDigit
3179  * @param control PriceControlMask
3180  */
3181 #define emberAfFillCommandPriceClusterPublishConversionFactor(                                                                     \
3182     issuerEventId, providerId, startTime, issuerEventId, conversionFactor, priceAckTime, conversionFactorTrailingDigit, control)   \
3183     emberAfFillExternalBuffer(mask,                                                                                                \
3184                                                                                                                                    \
3185                               ZCL_PUBLISH_CONVERSION_FACTOR_COMMAND_ID, "uuuuuuuu", issuerEventId, providerId, startTime,          \
3186                               issuerEventId, conversionFactor, priceAckTime, conversionFactorTrailingDigit, control);
3187
3188 /** @brief Command description for PublishCalorificValue
3189  *
3190  * Command: PublishCalorificValue
3191  * @param issuerEventId INT32U
3192  * @param startTime UTC_TIME
3193  * @param startTime UTC_TIME
3194  * @param numberOfEvents INT8U
3195  * @param calorificValue INT32U
3196  * @param tariffType TariffType
3197  * @param calorificValueUnit CalorificValueUnit
3198  * @param calorificValueTrailingDigit CalorificValueTrailingDigit
3199  */
3200 #define emberAfFillCommandPriceClusterPublishCalorificValue(issuerEventId, startTime, startTime, numberOfEvents, calorificValue,   \
3201                                                             tariffType, calorificValueUnit, calorificValueTrailingDigit)           \
3202     emberAfFillExternalBuffer(mask,                                                                                                \
3203                                                                                                                                    \
3204                               ZCL_PUBLISH_CALORIFIC_VALUE_COMMAND_ID, "uuuuuuuu", issuerEventId, startTime, startTime,             \
3205                               numberOfEvents, calorificValue, tariffType, calorificValueUnit, calorificValueTrailingDigit);
3206
3207 /** @brief Command description for PublishTariffInformation
3208  *
3209  * Command: PublishTariffInformation
3210  * @param providerId INT32U
3211  * @param earliestStartTime UTC_TIME
3212  * @param issuerEventId INT32U
3213  * @param minIssuerEventId INT32U
3214  * @param issuerTariffId INT32U
3215  * @param numberOfCommands INT8U
3216  * @param startTime UTC_TIME
3217  * @param tariffTypeChargingScheme TariffTypeChargingScheme
3218  * @param tariffLabel OCTET_STRING
3219  * @param numberOfPriceTiersInUse INT8U
3220  * @param numberOfBlockThresholdsInUse INT8U
3221  * @param unitOfMeasure AmiUnitOfMeasure
3222  * @param currency INT16U
3223  * @param priceTrailingDigit PriceTrailingDigit
3224  * @param standingCharge INT32U
3225  * @param tierBlockMode TierBlockMode
3226  * @param blockThresholdMultiplier INT24U
3227  * @param blockThresholdDivisor INT24U
3228  */
3229 #define emberAfFillCommandPriceClusterPublishTariffInformation(                                                                    \
3230     providerId, earliestStartTime, issuerEventId, minIssuerEventId, issuerTariffId, numberOfCommands, startTime,                   \
3231     tariffTypeChargingScheme, tariffLabel, numberOfPriceTiersInUse, numberOfBlockThresholdsInUse, unitOfMeasure, currency,         \
3232     priceTrailingDigit, standingCharge, tierBlockMode, blockThresholdMultiplier, blockThresholdDivisor)                            \
3233     emberAfFillExternalBuffer(mask,                                                                                                \
3234                                                                                                                                    \
3235                               ZCL_PUBLISH_TARIFF_INFORMATION_COMMAND_ID, "uuuuuuuuuuuuuuuuuu", providerId, earliestStartTime,      \
3236                               issuerEventId, minIssuerEventId, issuerTariffId, numberOfCommands, startTime,                        \
3237                               tariffTypeChargingScheme, tariffLabel, numberOfPriceTiersInUse, numberOfBlockThresholdsInUse,        \
3238                               unitOfMeasure, currency, priceTrailingDigit, standingCharge, tierBlockMode,                          \
3239                               blockThresholdMultiplier, blockThresholdDivisor);
3240
3241 /** @brief Command description for PublishPriceMatrix
3242  *
3243  * Command: PublishPriceMatrix
3244  * @param providerId INT32U
3245  * @param earliestStartTime UTC_TIME
3246  * @param issuerEventId INT32U
3247  * @param minIssuerEventId INT32U
3248  * @param startTime UTC_TIME
3249  * @param numberOfCommands INT8U
3250  * @param issuerTariffId INT32U
3251  * @param commandIndex INT8U
3252  * @param numberOfCommands INT8U
3253  * @param subPayloadControl PriceMatrixSubPayloadControl
3254  * @param payload PriceMatrixSubPayload []
3255  * @param payloadLen int
3256  */
3257 #define emberAfFillCommandPriceClusterPublishPriceMatrix(providerId, earliestStartTime, issuerEventId, minIssuerEventId,           \
3258                                                          startTime, numberOfCommands, issuerTariffId, commandIndex,                \
3259                                                          numberOfCommands, subPayloadControl, payload, payloadLen)                 \
3260     emberAfFillExternalBuffer(mask,                                                                                                \
3261                                                                                                                                    \
3262                               ZCL_PUBLISH_PRICE_MATRIX_COMMAND_ID, "uuuuuuuuuub", providerId, earliestStartTime, issuerEventId,    \
3263                               minIssuerEventId, startTime, numberOfCommands, issuerTariffId, commandIndex, numberOfCommands,       \
3264                               subPayloadControl, payload, payloadLen);
3265
3266 /** @brief Command description for PublishBlockThresholds
3267  *
3268  * Command: PublishBlockThresholds
3269  * @param providerId INT32U
3270  * @param earliestStartTime UTC_TIME
3271  * @param issuerEventId INT32U
3272  * @param minIssuerEventId INT32U
3273  * @param startTime UTC_TIME
3274  * @param numberOfCommands INT8U
3275  * @param issuerTariffId INT32U
3276  * @param tariffType TariffType
3277  * @param commandIndex INT8U
3278  * @param numberOfCommands INT8U
3279  * @param subPayloadControl BlockThresholdSubPayloadControl
3280  * @param payload BlockThresholdSubPayload []
3281  * @param payloadLen int
3282  */
3283 #define emberAfFillCommandPriceClusterPublishBlockThresholds(                                                                      \
3284     providerId, earliestStartTime, issuerEventId, minIssuerEventId, startTime, numberOfCommands, issuerTariffId, tariffType,       \
3285     commandIndex, numberOfCommands, subPayloadControl, payload, payloadLen)                                                        \
3286     emberAfFillExternalBuffer(mask,                                                                                                \
3287                                                                                                                                    \
3288                               ZCL_PUBLISH_BLOCK_THRESHOLDS_COMMAND_ID, "uuuuuuuuuuub", providerId, earliestStartTime,              \
3289                               issuerEventId, minIssuerEventId, startTime, numberOfCommands, issuerTariffId, tariffType,            \
3290                               commandIndex, numberOfCommands, subPayloadControl, payload, payloadLen);
3291
3292 /** @brief Command description for PublishCO2Value
3293  *
3294  * Command: PublishCO2Value
3295  * @param providerId INT32U
3296  * @param issuerTariffId INT32U
3297  * @param issuerEventId INT32U
3298  * @param startTime UTC_TIME
3299  * @param tariffType TariffType
3300  * @param cO2Value INT32U
3301  * @param cO2ValueUnit CO2Unit
3302  * @param cO2ValueTrailingDigit CO2TrailingDigit
3303  */
3304 #define emberAfFillCommandPriceClusterPublishCO2Value(providerId, issuerTariffId, issuerEventId, startTime, tariffType, cO2Value,  \
3305                                                       cO2ValueUnit, cO2ValueTrailingDigit)                                         \
3306     emberAfFillExternalBuffer(mask,                                                                                                \
3307                                                                                                                                    \
3308                               ZCL_PUBLISH_CO2_VALUE_COMMAND_ID, "uuuuuuuu", providerId, issuerTariffId, issuerEventId, startTime,  \
3309                               tariffType, cO2Value, cO2ValueUnit, cO2ValueTrailingDigit);
3310
3311 /** @brief Command description for PublishTierLabels
3312  *
3313  * Command: PublishTierLabels
3314  * @param providerId INT32U
3315  * @param issuerTariffId INT32U
3316  * @param issuerEventId INT32U
3317  * @param issuerTariffId INT32U
3318  * @param commandIndex INT8U
3319  * @param numberOfCommands INT8U
3320  * @param numberOfLabels INT8U
3321  * @param tierLabelsPayload INT8U []
3322  * @param tierLabelsPayloadLen int
3323  */
3324 #define emberAfFillCommandPriceClusterPublishTierLabels(providerId, issuerTariffId, issuerEventId, issuerTariffId, commandIndex,   \
3325                                                         numberOfCommands, numberOfLabels, tierLabelsPayload, tierLabelsPayloadLen) \
3326     emberAfFillExternalBuffer(mask,                                                                                                \
3327                                                                                                                                    \
3328                               ZCL_PUBLISH_TIER_LABELS_COMMAND_ID, "uuuuuuub", providerId, issuerTariffId, issuerEventId,           \
3329                               issuerTariffId, commandIndex, numberOfCommands, numberOfLabels, tierLabelsPayload,                   \
3330                               tierLabelsPayloadLen);
3331
3332 /** @brief Command description for PublishBillingPeriod
3333  *
3334  * Command: PublishBillingPeriod
3335  * @param providerId INT32U
3336  * @param earliestStartTime UTC_TIME
3337  * @param issuerEventId INT32U
3338  * @param minIssuerEventId INT32U
3339  * @param billingPeriodStartTime UTC_TIME
3340  * @param numberOfCommands INT8U
3341  * @param billingPeriodDuration BillingPeriodDuration
3342  * @param tariffType TariffType
3343  * @param billingPeriodDurationType BillingPeriodDurationType
3344  * @param tariffType TariffType
3345  */
3346 #define emberAfFillCommandPriceClusterPublishBillingPeriod(providerId, earliestStartTime, issuerEventId, minIssuerEventId,         \
3347                                                            billingPeriodStartTime, numberOfCommands, billingPeriodDuration,        \
3348                                                            tariffType, billingPeriodDurationType, tariffType)                      \
3349     emberAfFillExternalBuffer(mask,                                                                                                \
3350                                                                                                                                    \
3351                               ZCL_PUBLISH_BILLING_PERIOD_COMMAND_ID, "uuuuuuuuuu", providerId, earliestStartTime, issuerEventId,   \
3352                               minIssuerEventId, billingPeriodStartTime, numberOfCommands, billingPeriodDuration, tariffType,       \
3353                               billingPeriodDurationType, tariffType);
3354
3355 /** @brief Command description for PublishConsolidatedBill
3356  *
3357  * Command: PublishConsolidatedBill
3358  * @param providerId INT32U
3359  * @param issuerTariffId INT32U
3360  * @param issuerEventId INT32U
3361  * @param billingPeriodStartTime UTC_TIME
3362  * @param billingPeriodDuration BillingPeriodDuration
3363  * @param billingPeriodDurationType BillingPeriodDurationType
3364  * @param tariffType TariffType
3365  * @param consolidatedBill INT32U
3366  * @param currency INT16U
3367  * @param billTrailingDigit BillTrailingDigit
3368  */
3369 #define emberAfFillCommandPriceClusterPublishConsolidatedBill(providerId, issuerTariffId, issuerEventId, billingPeriodStartTime,   \
3370                                                               billingPeriodDuration, billingPeriodDurationType, tariffType,        \
3371                                                               consolidatedBill, currency, billTrailingDigit)                       \
3372     emberAfFillExternalBuffer(mask,                                                                                                \
3373                                                                                                                                    \
3374                               ZCL_PUBLISH_CONSOLIDATED_BILL_COMMAND_ID, "uuuuuuuuuu", providerId, issuerTariffId, issuerEventId,   \
3375                               billingPeriodStartTime, billingPeriodDuration, billingPeriodDurationType, tariffType,                \
3376                               consolidatedBill, currency, billTrailingDigit);
3377
3378 /** @brief Command description for PublishCppEvent
3379  *
3380  * Command: PublishCppEvent
3381  * @param providerId INT32U
3382  * @param earliestStartTime UTC_TIME
3383  * @param issuerEventId INT32U
3384  * @param minIssuerEventId INT32U
3385  * @param startTime UTC_TIME
3386  * @param numberOfCommands INT8U
3387  * @param durationInMinutes INT16U
3388  * @param tariffType TariffType
3389  * @param tariffType TariffType
3390  * @param cppPriceTier CppPriceTier
3391  * @param cppAuth PublishCppEventCppAuth
3392  */
3393 #define emberAfFillCommandPriceClusterPublishCppEvent(providerId, earliestStartTime, issuerEventId, minIssuerEventId, startTime,   \
3394                                                       numberOfCommands, durationInMinutes, tariffType, tariffType, cppPriceTier,   \
3395                                                       cppAuth)                                                                     \
3396     emberAfFillExternalBuffer(mask,                                                                                                \
3397                                                                                                                                    \
3398                               ZCL_PUBLISH_CPP_EVENT_COMMAND_ID, "uuuuuuuuuuu", providerId, earliestStartTime, issuerEventId,       \
3399                               minIssuerEventId, startTime, numberOfCommands, durationInMinutes, tariffType, tariffType,            \
3400                               cppPriceTier, cppAuth);
3401
3402 /** @brief Command description for PublishCreditPayment
3403  *
3404  * Command: PublishCreditPayment
3405  * @param providerId INT32U
3406  * @param earliestStartTime UTC_TIME
3407  * @param issuerEventId INT32U
3408  * @param minIssuerEventId INT32U
3409  * @param creditPaymentDueDate UTC_TIME
3410  * @param numberOfCommands INT8U
3411  * @param creditPaymentOverDueAmount INT32U
3412  * @param tariffType TariffType
3413  * @param creditPaymentStatus CreditPaymentStatus
3414  * @param creditPayment INT32U
3415  * @param creditPaymentDate UTC_TIME
3416  * @param creditPaymentRef OCTET_STRING
3417  */
3418 #define emberAfFillCommandPriceClusterPublishCreditPayment(                                                                        \
3419     providerId, earliestStartTime, issuerEventId, minIssuerEventId, creditPaymentDueDate, numberOfCommands,                        \
3420     creditPaymentOverDueAmount, tariffType, creditPaymentStatus, creditPayment, creditPaymentDate, creditPaymentRef)               \
3421     emberAfFillExternalBuffer(mask,                                                                                                \
3422                                                                                                                                    \
3423                               ZCL_PUBLISH_CREDIT_PAYMENT_COMMAND_ID, "uuuuuuuuuuuu", providerId, earliestStartTime, issuerEventId, \
3424                               minIssuerEventId, creditPaymentDueDate, numberOfCommands, creditPaymentOverDueAmount, tariffType,    \
3425                               creditPaymentStatus, creditPayment, creditPaymentDate, creditPaymentRef);
3426
3427 /** @brief Command description for PublishCurrencyConversion
3428  *
3429  * Command: PublishCurrencyConversion
3430  * @param providerId INT32U
3431  * @param issuerEventId INT32U
3432  * @param issuerEventId INT32U
3433  * @param cppAuth CppEventResponseCppAuth
3434  * @param startTime UTC_TIME
3435  * @param oldCurrency INT16U
3436  * @param newCurrency INT16U
3437  * @param conversionFactor INT32U
3438  * @param conversionFactorTrailingDigit ConversionFactorTrailingDigit
3439  * @param currencyChangeControlFlags CurrencyChangeControl
3440  */
3441 #define emberAfFillCommandPriceClusterPublishCurrencyConversion(providerId, issuerEventId, issuerEventId, cppAuth, startTime,      \
3442                                                                 oldCurrency, newCurrency, conversionFactor,                        \
3443                                                                 conversionFactorTrailingDigit, currencyChangeControlFlags)         \
3444     emberAfFillExternalBuffer(mask,                                                                                                \
3445                                                                                                                                    \
3446                               ZCL_PUBLISH_CURRENCY_CONVERSION_COMMAND_ID, "uuuuuuuuuu", providerId, issuerEventId, issuerEventId,  \
3447                               cppAuth, startTime, oldCurrency, newCurrency, conversionFactor, conversionFactorTrailingDigit,       \
3448                               currencyChangeControlFlags);
3449
3450 /** @brief Command description for CancelTariff
3451  *
3452  * Command: CancelTariff
3453  * @param providerId INT32U
3454  * @param latestEndTime UTC_TIME
3455  * @param issuerTariffId INT32U
3456  * @param numberOfRecords INT8U
3457  * @param tariffType TariffType
3458  */
3459 #define emberAfFillCommandPriceClusterCancelTariff(providerId, latestEndTime, issuerTariffId, numberOfRecords, tariffType)         \
3460     emberAfFillExternalBuffer(mask,                                                                                                \
3461                                                                                                                                    \
3462                               ZCL_CANCEL_TARIFF_COMMAND_ID, "uuuuu", providerId, latestEndTime, issuerTariffId, numberOfRecords,   \
3463                               tariffType);
3464
3465 /** @brief Command description for GetCurrencyConversionCommand
3466  *
3467  * Command: GetCurrencyConversionCommand
3468  */
3469 #define emberAfFillCommandPriceClusterGetCurrencyConversionCommand()                                                               \
3470     emberAfFillExternalBuffer(mask,                                                                                                \
3471                                                                                                                                    \
3472                               ZCL_GET_CURRENCY_CONVERSION_COMMAND_COMMAND_ID, "", );
3473
3474 /** @brief Command description for GetTariffCancellation
3475  *
3476  * Command: GetTariffCancellation
3477  */
3478 #define emberAfFillCommandPriceClusterGetTariffCancellation()                                                                      \
3479     emberAfFillExternalBuffer(mask,                                                                                                \
3480                                                                                                                                    \
3481                               ZCL_GET_TARIFF_CANCELLATION_COMMAND_ID, "", );
3482
3483 /** @brief Command description for LoadControlEvent
3484  *
3485  * Command: LoadControlEvent
3486  * @param issuerEventId INT32U
3487  * @param issuerEventId INT32U
3488  * @param deviceClass AmiDeviceClass
3489  * @param eventStatus AmiEventStatus
3490  * @param utilityEnrollmentGroup INT8U
3491  * @param eventStatusTime UTC_TIME
3492  * @param startTime UTC_TIME
3493  * @param criticalityLevelApplied AmiCriticalityLevel
3494  * @param durationInMinutes INT16U
3495  * @param coolingTemperatureSetPointApplied INT16U
3496  * @param criticalityLevel AmiCriticalityLevel
3497  * @param heatingTemperatureSetPointApplied INT16U
3498  * @param coolingTemperatureOffset INT8U
3499  * @param averageLoadAdjustmentPercentageApplied INT8S
3500  * @param heatingTemperatureOffset INT8U
3501  * @param dutyCycleApplied INT8U
3502  * @param coolingTemperatureSetPoint INT16S
3503  * @param eventControl AmiEventControl
3504  * @param heatingTemperatureSetPoint INT16S
3505  * @param signatureType SignatureType
3506  * @param averageLoadAdjustmentPercentage INT8S
3507  * @param signature Signature
3508  * @param dutyCycle INT8U
3509  * @param eventControl AmiEventControl
3510  */
3511 #define emberAfFillCommandDemand                                                                                                   \
3512     Response and Load ControlClusterLoadControlEvent(                                                                              \
3513         issuerEventId, issuerEventId, deviceClass, eventStatus, utilityEnrollmentGroup, eventStatusTime, startTime,                \
3514         criticalityLevelApplied, durationInMinutes, coolingTemperatureSetPointApplied, criticalityLevel,                           \
3515         heatingTemperatureSetPointApplied, coolingTemperatureOffset, averageLoadAdjustmentPercentageApplied,                       \
3516         heatingTemperatureOffset, dutyCycleApplied, coolingTemperatureSetPoint, eventControl, heatingTemperatureSetPoint,          \
3517         signatureType, averageLoadAdjustmentPercentage, signature, dutyCycle, eventControl)                                        \
3518         emberAfFillExternalBuffer(mask,                                                                                            \
3519                                                                                                                                    \
3520                                   ZCL_LOAD_CONTROL_EVENT_COMMAND_ID, "uuuuuuuuuuuuuuuuuuuuuuuu", issuerEventId, issuerEventId,     \
3521                                   deviceClass, eventStatus, utilityEnrollmentGroup, eventStatusTime, startTime,                    \
3522                                   criticalityLevelApplied, durationInMinutes, coolingTemperatureSetPointApplied, criticalityLevel, \
3523                                   heatingTemperatureSetPointApplied, coolingTemperatureOffset,                                     \
3524                                   averageLoadAdjustmentPercentageApplied, heatingTemperatureOffset, dutyCycleApplied,              \
3525                                   coolingTemperatureSetPoint, eventControl, heatingTemperatureSetPoint, signatureType,             \
3526                                   averageLoadAdjustmentPercentage, signature, dutyCycle, eventControl);
3527
3528 /** @brief Command description for CancelLoadControlEvent
3529  *
3530  * Command: CancelLoadControlEvent
3531  * @param issuerEventId INT32U
3532  * @param startTime UTC_TIME
3533  * @param deviceClass AmiDeviceClass
3534  * @param numberOfEvents INT8U
3535  * @param utilityEnrollmentGroup INT8U
3536  * @param issuerEventId INT32U
3537  * @param cancelControl AmiCancelControl
3538  * @param effectiveTime UTC_TIME
3539  */
3540 #define emberAfFillCommandDemand                                                                                                   \
3541     Response and Load ControlClusterCancelLoadControlEvent(issuerEventId, startTime, deviceClass, numberOfEvents,                  \
3542                                                            utilityEnrollmentGroup, issuerEventId, cancelControl, effectiveTime)    \
3543         emberAfFillExternalBuffer(mask,                                                                                            \
3544                                                                                                                                    \
3545                                   ZCL_CANCEL_LOAD_CONTROL_EVENT_COMMAND_ID, "uuuuuuuu", issuerEventId, startTime, deviceClass,     \
3546                                   numberOfEvents, utilityEnrollmentGroup, issuerEventId, cancelControl, effectiveTime);
3547
3548 /** @brief Command description for CancelAllLoadControlEvents
3549  *
3550  * Command: CancelAllLoadControlEvents
3551  * @param cancelControl AmiCancelControl
3552  */
3553 #define emberAfFillCommandDemand                                                                                                   \
3554     Response and Load ControlClusterCancelAllLoadControlEvents(cancelControl)                                                      \
3555         emberAfFillExternalBuffer(mask,                                                                                            \
3556                                                                                                                                    \
3557                                   ZCL_CANCEL_ALL_LOAD_CONTROL_EVENTS_COMMAND_ID, "u", cancelControl);
3558
3559 /** @brief Command description for GetProfileResponse
3560  *
3561  * Command: GetProfileResponse
3562  * @param endTime UTC_TIME
3563  * @param intervalChannel AmiIntervalChannel
3564  * @param status AmiGetProfileStatus
3565  * @param endTime UTC_TIME
3566  * @param profileIntervalPeriod AmiIntervalPeriod
3567  * @param numberOfPeriods INT8U
3568  * @param numberOfPeriodsDelivered INT8U
3569  * @param intervals INT24U []
3570  * @param intervalsLen int
3571  */
3572 #define emberAfFillCommandSimple                                                                                                   \
3573     MeteringClusterGetProfileResponse(endTime, intervalChannel, status, endTime, profileIntervalPeriod, numberOfPeriods,           \
3574                                       numberOfPeriodsDelivered, intervals, intervalsLen)                                           \
3575         emberAfFillExternalBuffer(mask,                                                                                            \
3576                                                                                                                                    \
3577                                   ZCL_GET_PROFILE_RESPONSE_COMMAND_ID, "uuuuuuub", endTime, intervalChannel, status, endTime,      \
3578                                   profileIntervalPeriod, numberOfPeriods, numberOfPeriodsDelivered, intervals, intervalsLen);
3579
3580 /** @brief Command description for RequestMirror
3581  *
3582  * Command: RequestMirror
3583  * @param endpointId INT16U
3584  */
3585 #define emberAfFillCommandSimple                                                                                                   \
3586     MeteringClusterRequestMirror(endpointId) emberAfFillExternalBuffer(mask,                                                       \
3587                                                                                                                                    \
3588                                                                        ZCL_REQUEST_MIRROR_COMMAND_ID, "u", endpointId);
3589
3590 /** @brief Command description for RemoveMirror
3591  *
3592  * Command: RemoveMirror
3593  * @param endpointId INT16U
3594  */
3595 #define emberAfFillCommandSimple                                                                                                   \
3596     MeteringClusterRemoveMirror(endpointId) emberAfFillExternalBuffer(mask,                                                        \
3597                                                                                                                                    \
3598                                                                       ZCL_REMOVE_MIRROR_COMMAND_ID, "u", endpointId);
3599
3600 /** @brief Command description for RequestFastPollModeResponse
3601  *
3602  * Command: RequestFastPollModeResponse
3603  * @param appliedUpdatePeriod INT8U
3604  * @param fastPollUpdatePeriod INT8U
3605  * @param fastPollModeEndtime UTC_TIME
3606  * @param duration INT8U
3607  */
3608 #define emberAfFillCommandSimple                                                                                                   \
3609     MeteringClusterRequestFastPollModeResponse(appliedUpdatePeriod, fastPollUpdatePeriod, fastPollModeEndtime, duration)           \
3610         emberAfFillExternalBuffer(mask,                                                                                            \
3611                                                                                                                                    \
3612                                   ZCL_REQUEST_FAST_POLL_MODE_RESPONSE_COMMAND_ID, "uuuu", appliedUpdatePeriod,                     \
3613                                   fastPollUpdatePeriod, fastPollModeEndtime, duration);
3614
3615 /** @brief Command description for ScheduleSnapshotResponse
3616  *
3617  * Command: ScheduleSnapshotResponse
3618  * @param issuerEventId INT32U
3619  * @param issuerEventId INT32U
3620  * @param snapshotResponsePayload SnapshotResponsePayload []
3621  * @param snapshotResponsePayloadLen int
3622  * @param commandIndex INT8U
3623  * @param commandCount INT8U
3624  * @param snapshotSchedulePayload SnapshotSchedulePayload []
3625  * @param snapshotSchedulePayloadLen int
3626  */
3627 #define emberAfFillCommandSimple                                                                                                   \
3628     MeteringClusterScheduleSnapshotResponse(issuerEventId, issuerEventId, snapshotResponsePayload, snapshotResponsePayloadLen,     \
3629                                             commandIndex, commandCount, snapshotSchedulePayload, snapshotSchedulePayloadLen)       \
3630         emberAfFillExternalBuffer(mask,                                                                                            \
3631                                                                                                                                    \
3632                                   ZCL_SCHEDULE_SNAPSHOT_RESPONSE_COMMAND_ID, "uubuub", issuerEventId, issuerEventId,               \
3633                                   snapshotResponsePayload, snapshotResponsePayloadLen, commandIndex, commandCount,                 \
3634                                   snapshotSchedulePayload, snapshotSchedulePayloadLen);
3635
3636 /** @brief Command description for TakeSnapshotResponse
3637  *
3638  * Command: TakeSnapshotResponse
3639  * @param snapshotId INT32U
3640  * @param snapshotCause SnapshotCause
3641  * @param snapshotConfirmation SnapshotConfirmation
3642  */
3643 #define emberAfFillCommandSimple                                                                                                   \
3644     MeteringClusterTakeSnapshotResponse(snapshotId, snapshotCause, snapshotConfirmation)                                           \
3645         emberAfFillExternalBuffer(mask,                                                                                            \
3646                                                                                                                                    \
3647                                   ZCL_TAKE_SNAPSHOT_RESPONSE_COMMAND_ID, "uuu", snapshotId, snapshotCause, snapshotConfirmation);
3648
3649 /** @brief Command description for PublishSnapshot
3650  *
3651  * Command: PublishSnapshot
3652  * @param snapshotId INT32U
3653  * @param earliestStartTime UTC_TIME
3654  * @param snapshotTime UTC_TIME
3655  * @param latestEndTime UTC_TIME
3656  * @param totalSnapshotsFound INT8U
3657  * @param snapshotOffset INT8U
3658  * @param commandIndex INT8U
3659  * @param snapshotCause SnapshotCause
3660  * @param totalCommands INT8U
3661  * @param snapshotCause SnapshotCause
3662  * @param snapshotPayloadType SnapshotPayloadType
3663  * @param snapshotPayload INT8U []
3664  * @param snapshotPayloadLen int
3665  */
3666 #define emberAfFillCommandSimple                                                                                                   \
3667     MeteringClusterPublishSnapshot(snapshotId, earliestStartTime, snapshotTime, latestEndTime, totalSnapshotsFound,                \
3668                                    snapshotOffset, commandIndex, snapshotCause, totalCommands, snapshotCause, snapshotPayloadType, \
3669                                    snapshotPayload, snapshotPayloadLen)                                                            \
3670         emberAfFillExternalBuffer(mask,                                                                                            \
3671                                                                                                                                    \
3672                                   ZCL_PUBLISH_SNAPSHOT_COMMAND_ID, "uuuuuuuuuuub", snapshotId, earliestStartTime, snapshotTime,    \
3673                                   latestEndTime, totalSnapshotsFound, snapshotOffset, commandIndex, snapshotCause, totalCommands,  \
3674                                   snapshotCause, snapshotPayloadType, snapshotPayload, snapshotPayloadLen);
3675
3676 /** @brief Command description for GetSampledDataResponse
3677  *
3678  * Command: GetSampledDataResponse
3679  * @param sampleId INT16U
3680  * @param issuerEventId INT32U
3681  * @param sampleStartTime UTC_TIME
3682  * @param startSamplingTime UTC_TIME
3683  * @param sampleType SampleType
3684  * @param sampleType SampleType
3685  * @param sampleRequestInterval INT16U
3686  * @param sampleRequestInterval INT16U
3687  * @param numberOfSamples INT16U
3688  * @param maxNumberOfSamples INT16U
3689  * @param samples INT24U []
3690  * @param samplesLen int
3691  */
3692 #define emberAfFillCommandSimple                                                                                                   \
3693     MeteringClusterGetSampledDataResponse(sampleId, issuerEventId, sampleStartTime, startSamplingTime, sampleType, sampleType,     \
3694                                           sampleRequestInterval, sampleRequestInterval, numberOfSamples, maxNumberOfSamples,       \
3695                                           samples, samplesLen)                                                                     \
3696         emberAfFillExternalBuffer(mask,                                                                                            \
3697                                                                                                                                    \
3698                                   ZCL_GET_SAMPLED_DATA_RESPONSE_COMMAND_ID, "uuuuuuuuuub", sampleId, issuerEventId,                \
3699                                   sampleStartTime, startSamplingTime, sampleType, sampleType, sampleRequestInterval,               \
3700                                   sampleRequestInterval, numberOfSamples, maxNumberOfSamples, samples, samplesLen);
3701
3702 /** @brief Command description for ConfigureMirror
3703  *
3704  * Command: ConfigureMirror
3705  * @param issuerEventId INT32U
3706  * @param sampleId INT16U
3707  * @param reportingInterval INT24U
3708  * @param earliestSampleTime UTC_TIME
3709  * @param mirrorNotificationReporting BOOLEAN
3710  * @param sampleType SampleType
3711  * @param notificationScheme INT8U
3712  * @param numberOfSamples INT16U
3713  */
3714 #define emberAfFillCommandSimple                                                                                                   \
3715     MeteringClusterConfigureMirror(issuerEventId, sampleId, reportingInterval, earliestSampleTime, mirrorNotificationReporting,    \
3716                                    sampleType, notificationScheme, numberOfSamples)                                                \
3717         emberAfFillExternalBuffer(mask,                                                                                            \
3718                                                                                                                                    \
3719                                   ZCL_CONFIGURE_MIRROR_COMMAND_ID, "uuuuuuuu", issuerEventId, sampleId, reportingInterval,         \
3720                                   earliestSampleTime, mirrorNotificationReporting, sampleType, notificationScheme,                 \
3721                                   numberOfSamples);
3722
3723 /** @brief Command description for ConfigureNotificationScheme
3724  *
3725  * Command: ConfigureNotificationScheme
3726  * @param issuerEventId INT32U
3727  * @param notificationScheme INT8U
3728  * @param notificationScheme INT8U
3729  * @param notificationFlags BITMAP32 []
3730  * @param notificationFlagsLen int
3731  * @param notificationFlagOrder BITMAP32
3732  */
3733 #define emberAfFillCommandSimple                                                                                                   \
3734     MeteringClusterConfigureNotificationScheme(issuerEventId, notificationScheme, notificationScheme, notificationFlags,           \
3735                                                notificationFlagsLen, notificationFlagOrder)                                        \
3736         emberAfFillExternalBuffer(mask,                                                                                            \
3737                                                                                                                                    \
3738                                   ZCL_CONFIGURE_NOTIFICATION_SCHEME_COMMAND_ID, "uuubu", issuerEventId, notificationScheme,        \
3739                                   notificationScheme, notificationFlags, notificationFlagsLen, notificationFlagOrder);
3740
3741 /** @brief Command description for ConfigureNotificationFlags
3742  *
3743  * Command: ConfigureNotificationFlags
3744  * @param issuerEventId INT32U
3745  * @param providerId INT32U
3746  * @param notificationScheme INT8U
3747  * @param issuerEventId INT32U
3748  * @param notificationFlagAttributeId INT16U
3749  * @param clusterId INT16U
3750  * @param manufacturerCode INT16U
3751  * @param numberOfCommands INT8U
3752  * @param commandIds INT8U []
3753  * @param commandIdsLen int
3754  */
3755 #define emberAfFillCommandSimple                                                                                                   \
3756     MeteringClusterConfigureNotificationFlags(issuerEventId, providerId, notificationScheme, issuerEventId,                        \
3757                                               notificationFlagAttributeId, clusterId, manufacturerCode, numberOfCommands,          \
3758                                               commandIds, commandIdsLen)                                                           \
3759         emberAfFillExternalBuffer(mask,                                                                                            \
3760                                                                                                                                    \
3761                                   ZCL_CONFIGURE_NOTIFICATION_FLAGS_COMMAND_ID, "uuuuuuuub", issuerEventId, providerId,             \
3762                                   notificationScheme, issuerEventId, notificationFlagAttributeId, clusterId, manufacturerCode,     \
3763                                   numberOfCommands, commandIds, commandIdsLen);
3764
3765 /** @brief Command description for GetNotifiedMessage
3766  *
3767  * Command: GetNotifiedMessage
3768  * @param notificationScheme INT8U
3769  * @param providerId INT32U
3770  * @param notificationFlagAttributeId INT16U
3771  * @param issuerEventId INT32U
3772  * @param notificationFlagsN BITMAP32
3773  * @param requestDateTime UTC_TIME
3774  * @param implementationDateTime UTC_TIME
3775  * @param proposedSupplyStatus MeteringSupplyStatus
3776  * @param supplyControlBits SupplyControlBits
3777  */
3778 #define emberAfFillCommandSimple                                                                                                   \
3779     MeteringClusterGetNotifiedMessage(notificationScheme, providerId, notificationFlagAttributeId, issuerEventId,                  \
3780                                       notificationFlagsN, requestDateTime, implementationDateTime, proposedSupplyStatus,           \
3781                                       supplyControlBits)                                                                           \
3782         emberAfFillExternalBuffer(mask,                                                                                            \
3783                                                                                                                                    \
3784                                   ZCL_GET_NOTIFIED_MESSAGE_COMMAND_ID, "uuuuuuuuu", notificationScheme, providerId,                \
3785                                   notificationFlagAttributeId, issuerEventId, notificationFlagsN, requestDateTime,                 \
3786                                   implementationDateTime, proposedSupplyStatus, supplyControlBits);
3787
3788 /** @brief Command description for SupplyStatusResponse
3789  *
3790  * Command: SupplyStatusResponse
3791  * @param providerId INT32U
3792  * @param proposedSupplyStatus ProposedSupplyStatus
3793  * @param issuerEventId INT32U
3794  * @param implementationDateTime UTC_TIME
3795  * @param supplyStatus MeteringSupplyStatus
3796  */
3797 #define emberAfFillCommandSimple                                                                                                   \
3798     MeteringClusterSupplyStatusResponse(providerId, proposedSupplyStatus, issuerEventId, implementationDateTime, supplyStatus)     \
3799         emberAfFillExternalBuffer(mask,                                                                                            \
3800                                                                                                                                    \
3801                                   ZCL_SUPPLY_STATUS_RESPONSE_COMMAND_ID, "uuuuu", providerId, proposedSupplyStatus, issuerEventId, \
3802                                   implementationDateTime, supplyStatus);
3803
3804 /** @brief Command description for StartSamplingResponse
3805  *
3806  * Command: StartSamplingResponse
3807  * @param sampleId INT16U
3808  * @param issuerEventId INT32U
3809  * @param supplyTamperState SupplyStatus
3810  * @param supplyDepletionState SupplyStatus
3811  * @param supplyUncontrolledFlowState SupplyStatus
3812  * @param loadLimitSupplyState SupplyStatus
3813  */
3814 #define emberAfFillCommandSimple                                                                                                   \
3815     MeteringClusterStartSamplingResponse(sampleId, issuerEventId, supplyTamperState, supplyDepletionState,                         \
3816                                          supplyUncontrolledFlowState, loadLimitSupplyState)                                        \
3817         emberAfFillExternalBuffer(mask,                                                                                            \
3818                                                                                                                                    \
3819                                   ZCL_START_SAMPLING_RESPONSE_COMMAND_ID, "uuuuuu", sampleId, issuerEventId, supplyTamperState,    \
3820                                   supplyDepletionState, supplyUncontrolledFlowState, loadLimitSupplyState);
3821
3822 /** @brief Command description for SetUncontrolledFlowThreshold
3823  *
3824  * Command: SetUncontrolledFlowThreshold
3825  * @param providerId INT32U
3826  * @param issuerEventId INT32U
3827  * @param uncontrolledFlowThreshold INT16U
3828  * @param unitOfMeasure AmiUnitOfMeasure
3829  * @param multiplier INT16U
3830  * @param divisor INT16U
3831  * @param stabilisationPeriod INT8U
3832  * @param measurementPeriod INT16U
3833  */
3834 #define emberAfFillCommandSimple                                                                                                   \
3835     MeteringClusterSetUncontrolledFlowThreshold(providerId, issuerEventId, uncontrolledFlowThreshold, unitOfMeasure, multiplier,   \
3836                                                 divisor, stabilisationPeriod, measurementPeriod)                                   \
3837         emberAfFillExternalBuffer(mask,                                                                                            \
3838                                                                                                                                    \
3839                                   ZCL_SET_UNCONTROLLED_FLOW_THRESHOLD_COMMAND_ID, "uuuuuuuu", providerId, issuerEventId,           \
3840                                   uncontrolledFlowThreshold, unitOfMeasure, multiplier, divisor, stabilisationPeriod,              \
3841                                   measurementPeriod);
3842
3843 /** @brief Command description for GetLastMessage
3844  *
3845  * Command: GetLastMessage
3846  * @param messageId INT32U
3847  * @param messageControl MessagingControlMask
3848  * @param startTime UTC_TIME
3849  * @param durationInMinutes INT16U
3850  * @param message CHAR_STRING
3851  * @param optionalExtendedMessageControl MessagingExtendedControlMask
3852  */
3853 #define emberAfFillCommandMessagingClusterGetLastMessage(messageId, messageControl, startTime, durationInMinutes, message,         \
3854                                                          optionalExtendedMessageControl)                                           \
3855     emberAfFillExternalBuffer(mask,                                                                                                \
3856                                                                                                                                    \
3857                               ZCL_GET_LAST_MESSAGE_COMMAND_ID, "uuuuuu", messageId, messageControl, startTime, durationInMinutes,  \
3858                               message, optionalExtendedMessageControl);
3859
3860 /** @brief Command description for CancelMessage
3861  *
3862  * Command: CancelMessage
3863  * @param messageId INT32U
3864  * @param messageId INT32U
3865  * @param messageControl MessagingControlMask
3866  * @param confirmationTime UTC_TIME
3867  * @param messageConfirmationControl BITMAP8
3868  * @param messageResponse OCTET_STRING
3869  */
3870 #define emberAfFillCommandMessagingClusterCancelMessage(messageId, messageId, messageControl, confirmationTime,                    \
3871                                                         messageConfirmationControl, messageResponse)                               \
3872     emberAfFillExternalBuffer(mask,                                                                                                \
3873                                                                                                                                    \
3874                               ZCL_CANCEL_MESSAGE_COMMAND_ID, "uuuuuu", messageId, messageId, messageControl, confirmationTime,     \
3875                               messageConfirmationControl, messageResponse);
3876
3877 /** @brief Command description for DisplayProtectedMessage
3878  *
3879  * Command: DisplayProtectedMessage
3880  * @param messageId INT32U
3881  * @param earliestImplementationTime UTC_TIME
3882  * @param messageControl MessagingControlMask
3883  * @param startTime UTC_TIME
3884  * @param durationInMinutes INT16U
3885  * @param message CHAR_STRING
3886  * @param optionalExtendedMessageControl MessagingExtendedControlMask
3887  */
3888 #define emberAfFillCommandMessagingClusterDisplayProtectedMessage(                                                                 \
3889     messageId, earliestImplementationTime, messageControl, startTime, durationInMinutes, message, optionalExtendedMessageControl)  \
3890     emberAfFillExternalBuffer(mask,                                                                                                \
3891                                                                                                                                    \
3892                               ZCL_DISPLAY_PROTECTED_MESSAGE_COMMAND_ID, "uuuuuuu", messageId, earliestImplementationTime,          \
3893                               messageControl, startTime, durationInMinutes, message, optionalExtendedMessageControl);
3894
3895 /** @brief Command description for CancelAllMessages
3896  *
3897  * Command: CancelAllMessages
3898  * @param implementationDateTime UTC_TIME
3899  */
3900 #define emberAfFillCommandMessagingClusterCancelAllMessages(implementationDateTime)                                                \
3901     emberAfFillExternalBuffer(mask,                                                                                                \
3902                                                                                                                                    \
3903                               ZCL_CANCEL_ALL_MESSAGES_COMMAND_ID, "u", implementationDateTime);
3904
3905 /** @brief Command description for RequestTunnel
3906  *
3907  * Command: RequestTunnel
3908  * @param protocolId INT8U
3909  * @param tunnelId INT16U
3910  * @param manufacturerCode INT16U
3911  * @param tunnelStatus TunnelingTunnelStatus
3912  * @param flowControlSupport BOOLEAN
3913  * @param maximumIncomingTransferSize INT16U
3914  * @param maximumIncomingTransferSize INT16U
3915  */
3916 #define emberAfFillCommandTunnelingClusterRequestTunnel(protocolId, tunnelId, manufacturerCode, tunnelStatus, flowControlSupport,  \
3917                                                         maximumIncomingTransferSize, maximumIncomingTransferSize)                  \
3918     emberAfFillExternalBuffer(mask,                                                                                                \
3919                                                                                                                                    \
3920                               ZCL_REQUEST_TUNNEL_COMMAND_ID, "uuuuuuu", protocolId, tunnelId, manufacturerCode, tunnelStatus,      \
3921                               flowControlSupport, maximumIncomingTransferSize, maximumIncomingTransferSize);
3922
3923 /** @brief Command description for CloseTunnel
3924  *
3925  * Command: CloseTunnel
3926  * @param tunnelId INT16U
3927  * @param tunnelId INT16U
3928  * @param data INT8U []
3929  * @param dataLen int
3930  */
3931 #define emberAfFillCommandTunnelingClusterCloseTunnel(tunnelId, tunnelId, data, dataLen)                                           \
3932     emberAfFillExternalBuffer(mask,                                                                                                \
3933                                                                                                                                    \
3934                               ZCL_CLOSE_TUNNEL_COMMAND_ID, "uub", tunnelId, tunnelId, data, dataLen);
3935
3936 /** @brief Command description for TransferDataClientToServer
3937  *
3938  * Command: TransferDataClientToServer
3939  * @param tunnelId INT16U
3940  * @param tunnelId INT16U
3941  * @param data INT8U []
3942  * @param dataLen int
3943  * @param transferDataStatus TunnelingTransferDataStatus
3944  */
3945 #define emberAfFillCommandTunnelingClusterTransferDataClientToServer(tunnelId, tunnelId, data, dataLen, transferDataStatus)        \
3946     emberAfFillExternalBuffer(mask,                                                                                                \
3947                                                                                                                                    \
3948                               ZCL_TRANSFER_DATA_CLIENT_TO_SERVER_COMMAND_ID, "uubu", tunnelId, tunnelId, data, dataLen,            \
3949                               transferDataStatus);
3950
3951 /** @brief Command description for TransferDataErrorClientToServer
3952  *
3953  * Command: TransferDataErrorClientToServer
3954  * @param tunnelId INT16U
3955  * @param tunnelId INT16U
3956  * @param transferDataStatus TunnelingTransferDataStatus
3957  * @param numberOfBytesLeft INT16U
3958  */
3959 #define emberAfFillCommandTunnelingClusterTransferDataErrorClientToServer(tunnelId, tunnelId, transferDataStatus,                  \
3960                                                                           numberOfBytesLeft)                                       \
3961     emberAfFillExternalBuffer(mask,                                                                                                \
3962                                                                                                                                    \
3963                               ZCL_TRANSFER_DATA_ERROR_CLIENT_TO_SERVER_COMMAND_ID, "uuuu", tunnelId, tunnelId, transferDataStatus, \
3964                               numberOfBytesLeft);
3965
3966 /** @brief Command description for AckTransferDataClientToServer
3967  *
3968  * Command: AckTransferDataClientToServer
3969  * @param tunnelId INT16U
3970  * @param tunnelId INT16U
3971  * @param numberOfBytesLeft INT16U
3972  * @param numberOfOctetsLeft INT16U
3973  */
3974 #define emberAfFillCommandTunnelingClusterAckTransferDataClientToServer(tunnelId, tunnelId, numberOfBytesLeft, numberOfOctetsLeft) \
3975     emberAfFillExternalBuffer(mask,                                                                                                \
3976                                                                                                                                    \
3977                               ZCL_ACK_TRANSFER_DATA_CLIENT_TO_SERVER_COMMAND_ID, "uuuu", tunnelId, tunnelId, numberOfBytesLeft,    \
3978                               numberOfOctetsLeft);
3979
3980 /** @brief Command description for ReadyDataClientToServer
3981  *
3982  * Command: ReadyDataClientToServer
3983  * @param tunnelId INT16U
3984  * @param protocolListComplete BOOLEAN
3985  * @param numberOfOctetsLeft INT16U
3986  * @param protocolCount INT8U
3987  * @param protocolList Protocol []
3988  * @param protocolListLen int
3989  */
3990 #define emberAfFillCommandTunnelingClusterReadyDataClientToServer(tunnelId, protocolListComplete, numberOfOctetsLeft,              \
3991                                                                   protocolCount, protocolList, protocolListLen)                    \
3992     emberAfFillExternalBuffer(mask,                                                                                                \
3993                                                                                                                                    \
3994                               ZCL_READY_DATA_CLIENT_TO_SERVER_COMMAND_ID, "uuuub", tunnelId, protocolListComplete,                 \
3995                               numberOfOctetsLeft, protocolCount, protocolList, protocolListLen);
3996
3997 /** @brief Command description for GetSupportedTunnelProtocols
3998  *
3999  * Command: GetSupportedTunnelProtocols
4000  * @param protocolOffset INT8U
4001  * @param tunnelId INT16U
4002  */
4003 #define emberAfFillCommandTunnelingClusterGetSupportedTunnelProtocols(protocolOffset, tunnelId)                                    \
4004     emberAfFillExternalBuffer(mask,                                                                                                \
4005                                                                                                                                    \
4006                               ZCL_GET_SUPPORTED_TUNNEL_PROTOCOLS_COMMAND_ID, "uu", protocolOffset, tunnelId);
4007
4008 /** @brief Command description for SelectAvailableEmergencyCredit
4009  *
4010  * Command: SelectAvailableEmergencyCredit
4011  * @param commandIssueDateTime UTC_TIME
4012  * @param originatingDevice OriginatingDevice
4013  */
4014 #define emberAfFillCommandPrepaymentClusterSelectAvailableEmergencyCredit(commandIssueDateTime, originatingDevice)                 \
4015     emberAfFillExternalBuffer(mask,                                                                                                \
4016                                                                                                                                    \
4017                               ZCL_SELECT_AVAILABLE_EMERGENCY_CREDIT_COMMAND_ID, "uu", commandIssueDateTime, originatingDevice);
4018
4019 /** @brief Command description for PublishPrepaySnapshot
4020  *
4021  * Command: PublishPrepaySnapshot
4022  * @param snapshotId INT32U
4023  * @param snapshotTime UTC_TIME
4024  * @param totalSnapshotsFound INT8U
4025  * @param commandIndex INT8U
4026  * @param totalNumberOfCommands INT8U
4027  * @param snapshotCause PrepaySnapshotPayloadCause
4028  * @param snapshotPayloadType PrepaySnapshotPayloadType
4029  * @param snapshotPayload INT8U []
4030  * @param snapshotPayloadLen int
4031  */
4032 #define emberAfFillCommandPrepaymentClusterPublishPrepaySnapshot(snapshotId, snapshotTime, totalSnapshotsFound, commandIndex,      \
4033                                                                  totalNumberOfCommands, snapshotCause, snapshotPayloadType,        \
4034                                                                  snapshotPayload, snapshotPayloadLen)                              \
4035     emberAfFillExternalBuffer(mask,                                                                                                \
4036                                                                                                                                    \
4037                               ZCL_PUBLISH_PREPAY_SNAPSHOT_COMMAND_ID, "uuuuuuub", snapshotId, snapshotTime, totalSnapshotsFound,   \
4038                               commandIndex, totalNumberOfCommands, snapshotCause, snapshotPayloadType, snapshotPayload,            \
4039                               snapshotPayloadLen);
4040
4041 /** @brief Command description for ChangeDebt
4042  *
4043  * Command: ChangeDebt
4044  * @param issuerEventId INT32U
4045  * @param friendlyCredit FriendlyCredit
4046  * @param debtLabel OCTET_STRING
4047  * @param friendlyCreditCalendarId INT32U
4048  * @param debtAmount INT32U
4049  * @param emergencyCreditLimit INT32U
4050  * @param debtRecoveryMethod DebtRecoveryMethod
4051  * @param emergencyCreditThreshold INT32U
4052  * @param debtAmountType DebtAmountType
4053  * @param debtRecoveryStartTime UTC_TIME
4054  * @param debtRecoveryCollectionTime INT16U
4055  * @param debtRecoveryFrequency DebtRecoveryFrequency
4056  * @param debtRecoveryAmount INT32U
4057  * @param debtRecoveryBalancePercentage INT16U
4058  */
4059 #define emberAfFillCommandPrepaymentClusterChangeDebt(                                                                             \
4060     issuerEventId, friendlyCredit, debtLabel, friendlyCreditCalendarId, debtAmount, emergencyCreditLimit, debtRecoveryMethod,      \
4061     emergencyCreditThreshold, debtAmountType, debtRecoveryStartTime, debtRecoveryCollectionTime, debtRecoveryFrequency,            \
4062     debtRecoveryAmount, debtRecoveryBalancePercentage)                                                                             \
4063     emberAfFillExternalBuffer(mask,                                                                                                \
4064                                                                                                                                    \
4065                               ZCL_CHANGE_DEBT_COMMAND_ID, "uuuuuuuuuuuuuu", issuerEventId, friendlyCredit, debtLabel,              \
4066                               friendlyCreditCalendarId, debtAmount, emergencyCreditLimit, debtRecoveryMethod,                      \
4067                               emergencyCreditThreshold, debtAmountType, debtRecoveryStartTime, debtRecoveryCollectionTime,         \
4068                               debtRecoveryFrequency, debtRecoveryAmount, debtRecoveryBalancePercentage);
4069
4070 /** @brief Command description for EmergencyCreditSetup
4071  *
4072  * Command: EmergencyCreditSetup
4073  * @param issuerEventId INT32U
4074  * @param resultType ResultType
4075  * @param startTime UTC_TIME
4076  * @param topUpValue INT32U
4077  * @param emergencyCreditLimit INT32U
4078  * @param sourceOfTopUp OriginatingDevice
4079  * @param emergencyCreditThreshold INT32U
4080  * @param creditRemaining INT32U
4081  */
4082 #define emberAfFillCommandPrepaymentClusterEmergencyCreditSetup(issuerEventId, resultType, startTime, topUpValue,                  \
4083                                                                 emergencyCreditLimit, sourceOfTopUp, emergencyCreditThreshold,     \
4084                                                                 creditRemaining)                                                   \
4085     emberAfFillExternalBuffer(mask,                                                                                                \
4086                                                                                                                                    \
4087                               ZCL_EMERGENCY_CREDIT_SETUP_COMMAND_ID, "uuuuuuuu", issuerEventId, resultType, startTime, topUpValue, \
4088                               emergencyCreditLimit, sourceOfTopUp, emergencyCreditThreshold, creditRemaining);
4089
4090 /** @brief Command description for ConsumerTopUp
4091  *
4092  * Command: ConsumerTopUp
4093  * @param originatingDevice OriginatingDevice
4094  * @param topUpCode OCTET_STRING
4095  */
4096 #define emberAfFillCommandPrepaymentClusterConsumerTopUp(originatingDevice, topUpCode)                                             \
4097     emberAfFillExternalBuffer(mask,                                                                                                \
4098                                                                                                                                    \
4099                               ZCL_CONSUMER_TOP_UP_COMMAND_ID, "uu", originatingDevice, topUpCode);
4100
4101 /** @brief Command description for CreditAdjustment
4102  *
4103  * Command: CreditAdjustment
4104  * @param issuerEventId INT32U
4105  * @param commandIndex INT8U
4106  * @param startTime UTC_TIME
4107  * @param totalNumberOfCommands INT8U
4108  * @param creditAdjustmentType CreditAdjustmentType
4109  * @param topUpPayload TopUpPayload []
4110  * @param topUpPayloadLen int
4111  * @param creditAdjustmentValue INT32U
4112  */
4113 #define emberAfFillCommandPrepaymentClusterCreditAdjustment(issuerEventId, commandIndex, startTime, totalNumberOfCommands,         \
4114                                                             creditAdjustmentType, topUpPayload, topUpPayloadLen,                   \
4115                                                             creditAdjustmentValue)                                                 \
4116     emberAfFillExternalBuffer(mask,                                                                                                \
4117                                                                                                                                    \
4118                               ZCL_CREDIT_ADJUSTMENT_COMMAND_ID, "uuuuubu", issuerEventId, commandIndex, startTime,                 \
4119                               totalNumberOfCommands, creditAdjustmentType, topUpPayload, topUpPayloadLen, creditAdjustmentValue);
4120
4121 /** @brief Command description for ChangePaymentMode
4122  *
4123  * Command: ChangePaymentMode
4124  * @param providerId INT32U
4125  * @param commandIndex INT8U
4126  * @param issuerEventId INT32U
4127  * @param totalNumberOfCommands INT8U
4128  * @param implementationDateTime UTC_TIME
4129  * @param debtPayload DebtPayload []
4130  * @param debtPayloadLen int
4131  * @param proposedPaymentControlConfiguration PaymentControlConfiguration
4132  * @param cutOffValue INT32U
4133  */
4134 #define emberAfFillCommandPrepaymentClusterChangePaymentMode(providerId, commandIndex, issuerEventId, totalNumberOfCommands,       \
4135                                                              implementationDateTime, debtPayload, debtPayloadLen,                  \
4136                                                              proposedPaymentControlConfiguration, cutOffValue)                     \
4137     emberAfFillExternalBuffer(mask,                                                                                                \
4138                                                                                                                                    \
4139                               ZCL_CHANGE_PAYMENT_MODE_COMMAND_ID, "uuuuubuu", providerId, commandIndex, issuerEventId,             \
4140                               totalNumberOfCommands, implementationDateTime, debtPayload, debtPayloadLen,                          \
4141                               proposedPaymentControlConfiguration, cutOffValue);
4142
4143 /** @brief Command description for GetPrepaySnapshot
4144  *
4145  * Command: GetPrepaySnapshot
4146  * @param earliestStartTime UTC_TIME
4147  * @param latestEndTime UTC_TIME
4148  * @param snapshotOffset INT8U
4149  * @param snapshotCause PrepaySnapshotPayloadCause
4150  */
4151 #define emberAfFillCommandPrepaymentClusterGetPrepaySnapshot(earliestStartTime, latestEndTime, snapshotOffset, snapshotCause)      \
4152     emberAfFillExternalBuffer(mask,                                                                                                \
4153                                                                                                                                    \
4154                               ZCL_GET_PREPAY_SNAPSHOT_COMMAND_ID, "uuuu", earliestStartTime, latestEndTime, snapshotOffset,        \
4155                               snapshotCause);
4156
4157 /** @brief Command description for GetTopUpLog
4158  *
4159  * Command: GetTopUpLog
4160  * @param latestEndTime UTC_TIME
4161  * @param numberOfRecords INT8U
4162  */
4163 #define emberAfFillCommandPrepaymentClusterGetTopUpLog(latestEndTime, numberOfRecords)                                             \
4164     emberAfFillExternalBuffer(mask,                                                                                                \
4165                                                                                                                                    \
4166                               ZCL_GET_TOP_UP_LOG_COMMAND_ID, "uu", latestEndTime, numberOfRecords);
4167
4168 /** @brief Command description for SetLowCreditWarningLevel
4169  *
4170  * Command: SetLowCreditWarningLevel
4171  * @param lowCreditWarningLevel INT32U
4172  */
4173 #define emberAfFillCommandPrepaymentClusterSetLowCreditWarningLevel(lowCreditWarningLevel)                                         \
4174     emberAfFillExternalBuffer(mask,                                                                                                \
4175                                                                                                                                    \
4176                               ZCL_SET_LOW_CREDIT_WARNING_LEVEL_COMMAND_ID, "u", lowCreditWarningLevel);
4177
4178 /** @brief Command description for GetDebtRepaymentLog
4179  *
4180  * Command: GetDebtRepaymentLog
4181  * @param latestEndTime UTC_TIME
4182  * @param numberOfDebts INT8U
4183  * @param debtType RepaymentDebtType
4184  */
4185 #define emberAfFillCommandPrepaymentClusterGetDebtRepaymentLog(latestEndTime, numberOfDebts, debtType)                             \
4186     emberAfFillExternalBuffer(mask,                                                                                                \
4187                                                                                                                                    \
4188                               ZCL_GET_DEBT_REPAYMENT_LOG_COMMAND_ID, "uuu", latestEndTime, numberOfDebts, debtType);
4189
4190 /** @brief Command description for SetMaximumCreditLimit
4191  *
4192  * Command: SetMaximumCreditLimit
4193  * @param providerId INT32U
4194  * @param issuerEventId INT32U
4195  * @param implementationDateTime UTC_TIME
4196  * @param maximumCreditLevel INT32U
4197  * @param maximumCreditPerTopUp INT32U
4198  */
4199 #define emberAfFillCommandPrepaymentClusterSetMaximumCreditLimit(providerId, issuerEventId, implementationDateTime,                \
4200                                                                  maximumCreditLevel, maximumCreditPerTopUp)                        \
4201     emberAfFillExternalBuffer(mask,                                                                                                \
4202                                                                                                                                    \
4203                               ZCL_SET_MAXIMUM_CREDIT_LIMIT_COMMAND_ID, "uuuuu", providerId, issuerEventId, implementationDateTime, \
4204                               maximumCreditLevel, maximumCreditPerTopUp);
4205
4206 /** @brief Command description for SetOverallDebtCap
4207  *
4208  * Command: SetOverallDebtCap
4209  * @param providerId INT32U
4210  * @param issuerEventId INT32U
4211  * @param implementationDateTime UTC_TIME
4212  * @param overallDebtCap INT32U
4213  */
4214 #define emberAfFillCommandPrepaymentClusterSetOverallDebtCap(providerId, issuerEventId, implementationDateTime, overallDebtCap)    \
4215     emberAfFillExternalBuffer(mask,                                                                                                \
4216                                                                                                                                    \
4217                               ZCL_SET_OVERALL_DEBT_CAP_COMMAND_ID, "uuuu", providerId, issuerEventId, implementationDateTime,      \
4218                               overallDebtCap);
4219
4220 /** @brief Command description for ReportEventStatus
4221  *
4222  * Command: ReportEventStatus
4223  * @param issuerEventId INT32U
4224  * @param issuerEventId INT32U
4225  * @param eventStatus AmiEventStatus
4226  * @param deviceClass AmiDeviceClass
4227  * @param eventStatusTime UTC_TIME
4228  * @param utilityEnrollmentGroup INT8U
4229  * @param criticalityLevelApplied AmiCriticalityLevel
4230  * @param actionRequired INT8U
4231  * @param coolingTemperatureSetPointApplied INT16U
4232  * @param heatingTemperatureSetPointApplied INT16U
4233  * @param averageLoadAdjustmentPercentageApplied INT8S
4234  * @param dutyCycleApplied INT8U
4235  * @param eventControl AmiEventControl
4236  */
4237 #define emberAfFillCommandEnergy                                                                                                   \
4238     ManagementClusterReportEventStatus(issuerEventId, issuerEventId, eventStatus, deviceClass, eventStatusTime,                    \
4239                                        utilityEnrollmentGroup, criticalityLevelApplied, actionRequired,                            \
4240                                        coolingTemperatureSetPointApplied, heatingTemperatureSetPointApplied,                       \
4241                                        averageLoadAdjustmentPercentageApplied, dutyCycleApplied, eventControl)                     \
4242         emberAfFillExternalBuffer(mask,                                                                                            \
4243                                                                                                                                    \
4244                                   ZCL_REPORT_EVENT_STATUS_COMMAND_ID, "uuuuuuuuuuuuu", issuerEventId, issuerEventId, eventStatus,  \
4245                                   deviceClass, eventStatusTime, utilityEnrollmentGroup, criticalityLevelApplied, actionRequired,   \
4246                                   coolingTemperatureSetPointApplied, heatingTemperatureSetPointApplied,                            \
4247                                   averageLoadAdjustmentPercentageApplied, dutyCycleApplied, eventControl);
4248
4249 /** @brief Command description for PublishCalendar
4250  *
4251  * Command: PublishCalendar
4252  * @param providerId INT32U
4253  * @param earliestStartTime UTC_TIME
4254  * @param issuerEventId INT32U
4255  * @param minIssuerEventId INT32U
4256  * @param issuerCalendarId INT32U
4257  * @param numberOfCalendars INT8U
4258  * @param startTime UTC_TIME
4259  * @param calendarType CalendarType
4260  * @param calendarType CalendarType
4261  * @param providerId INT32U
4262  * @param calendarTimeReference CalendarTimeReference
4263  * @param calendarName OCTET_STRING
4264  * @param numberOfSeasons INT8U
4265  * @param numberOfWeekProfiles INT8U
4266  * @param numberOfDayProfiles INT8U
4267  */
4268 #define emberAfFillCommandCalendarClusterPublishCalendar(                                                                          \
4269     providerId, earliestStartTime, issuerEventId, minIssuerEventId, issuerCalendarId, numberOfCalendars, startTime, calendarType,  \
4270     calendarType, providerId, calendarTimeReference, calendarName, numberOfSeasons, numberOfWeekProfiles, numberOfDayProfiles)     \
4271     emberAfFillExternalBuffer(mask,                                                                                                \
4272                                                                                                                                    \
4273                               ZCL_PUBLISH_CALENDAR_COMMAND_ID, "uuuuuuuuuuuuuuu", providerId, earliestStartTime, issuerEventId,    \
4274                               minIssuerEventId, issuerCalendarId, numberOfCalendars, startTime, calendarType, calendarType,        \
4275                               providerId, calendarTimeReference, calendarName, numberOfSeasons, numberOfWeekProfiles,              \
4276                               numberOfDayProfiles);
4277
4278 /** @brief Command description for PublishDayProfile
4279  *
4280  * Command: PublishDayProfile
4281  * @param providerId INT32U
4282  * @param providerId INT32U
4283  * @param issuerEventId INT32U
4284  * @param issuerCalendarId INT32U
4285  * @param issuerCalendarId INT32U
4286  * @param startDayId INT8U
4287  * @param dayId INT8U
4288  * @param numberOfDays INT8U
4289  * @param totalNumberOfScheduleEntries INT8U
4290  * @param commandIndex INT8U
4291  * @param totalNumberOfCommands INT8U
4292  * @param calendarType CalendarType
4293  * @param dayScheduleEntries ScheduleEntry []
4294  * @param dayScheduleEntriesLen int
4295  */
4296 #define emberAfFillCommandCalendarClusterPublishDayProfile(                                                                        \
4297     providerId, providerId, issuerEventId, issuerCalendarId, issuerCalendarId, startDayId, dayId, numberOfDays,                    \
4298     totalNumberOfScheduleEntries, commandIndex, totalNumberOfCommands, calendarType, dayScheduleEntries, dayScheduleEntriesLen)    \
4299     emberAfFillExternalBuffer(mask,                                                                                                \
4300                                                                                                                                    \
4301                               ZCL_PUBLISH_DAY_PROFILE_COMMAND_ID, "uuuuuuuuuuuub", providerId, providerId, issuerEventId,          \
4302                               issuerCalendarId, issuerCalendarId, startDayId, dayId, numberOfDays, totalNumberOfScheduleEntries,   \
4303                               commandIndex, totalNumberOfCommands, calendarType, dayScheduleEntries, dayScheduleEntriesLen);
4304
4305 /** @brief Command description for PublishWeekProfile
4306  *
4307  * Command: PublishWeekProfile
4308  * @param providerId INT32U
4309  * @param providerId INT32U
4310  * @param issuerEventId INT32U
4311  * @param issuerCalendarId INT32U
4312  * @param issuerCalendarId INT32U
4313  * @param startWeekId INT8U
4314  * @param weekId INT8U
4315  * @param numberOfWeeks INT8U
4316  * @param dayIdRefMonday INT8U
4317  * @param dayIdRefTuesday INT8U
4318  * @param dayIdRefWednesday INT8U
4319  * @param dayIdRefThursday INT8U
4320  * @param dayIdRefFriday INT8U
4321  * @param dayIdRefSaturday INT8U
4322  * @param dayIdRefSunday INT8U
4323  */
4324 #define emberAfFillCommandCalendarClusterPublishWeekProfile(                                                                       \
4325     providerId, providerId, issuerEventId, issuerCalendarId, issuerCalendarId, startWeekId, weekId, numberOfWeeks, dayIdRefMonday, \
4326     dayIdRefTuesday, dayIdRefWednesday, dayIdRefThursday, dayIdRefFriday, dayIdRefSaturday, dayIdRefSunday)                        \
4327     emberAfFillExternalBuffer(mask,                                                                                                \
4328                                                                                                                                    \
4329                               ZCL_PUBLISH_WEEK_PROFILE_COMMAND_ID, "uuuuuuuuuuuuuuu", providerId, providerId, issuerEventId,       \
4330                               issuerCalendarId, issuerCalendarId, startWeekId, weekId, numberOfWeeks, dayIdRefMonday,              \
4331                               dayIdRefTuesday, dayIdRefWednesday, dayIdRefThursday, dayIdRefFriday, dayIdRefSaturday,              \
4332                               dayIdRefSunday);
4333
4334 /** @brief Command description for PublishSeasons
4335  *
4336  * Command: PublishSeasons
4337  * @param providerId INT32U
4338  * @param providerId INT32U
4339  * @param issuerEventId INT32U
4340  * @param issuerCalendarId INT32U
4341  * @param issuerCalendarId INT32U
4342  * @param commandIndex INT8U
4343  * @param totalNumberOfCommands INT8U
4344  * @param seasonEntries SeasonEntry []
4345  * @param seasonEntriesLen int
4346  */
4347 #define emberAfFillCommandCalendarClusterPublishSeasons(providerId, providerId, issuerEventId, issuerCalendarId, issuerCalendarId, \
4348                                                         commandIndex, totalNumberOfCommands, seasonEntries, seasonEntriesLen)      \
4349     emberAfFillExternalBuffer(mask,                                                                                                \
4350                                                                                                                                    \
4351                               ZCL_PUBLISH_SEASONS_COMMAND_ID, "uuuuuuub", providerId, providerId, issuerEventId, issuerCalendarId, \
4352                               issuerCalendarId, commandIndex, totalNumberOfCommands, seasonEntries, seasonEntriesLen);
4353
4354 /** @brief Command description for PublishSpecialDays
4355  *
4356  * Command: PublishSpecialDays
4357  * @param providerId INT32U
4358  * @param startTime UTC_TIME
4359  * @param issuerEventId INT32U
4360  * @param numberOfEvents INT8U
4361  * @param issuerCalendarId INT32U
4362  * @param calendarType CalendarType
4363  * @param startTime UTC_TIME
4364  * @param providerId INT32U
4365  * @param calendarType CalendarType
4366  * @param issuerCalendarId INT32U
4367  * @param totalNumberOfSpecialDays INT8U
4368  * @param commandIndex INT8U
4369  * @param totalNumberOfCommands INT8U
4370  * @param specialDayEntries SpecialDay []
4371  * @param specialDayEntriesLen int
4372  */
4373 #define emberAfFillCommandCalendarClusterPublishSpecialDays(                                                                       \
4374     providerId, startTime, issuerEventId, numberOfEvents, issuerCalendarId, calendarType, startTime, providerId, calendarType,     \
4375     issuerCalendarId, totalNumberOfSpecialDays, commandIndex, totalNumberOfCommands, specialDayEntries, specialDayEntriesLen)      \
4376     emberAfFillExternalBuffer(mask,                                                                                                \
4377                                                                                                                                    \
4378                               ZCL_PUBLISH_SPECIAL_DAYS_COMMAND_ID, "uuuuuuuuuuuuub", providerId, startTime, issuerEventId,         \
4379                               numberOfEvents, issuerCalendarId, calendarType, startTime, providerId, calendarType,                 \
4380                               issuerCalendarId, totalNumberOfSpecialDays, commandIndex, totalNumberOfCommands, specialDayEntries,  \
4381                               specialDayEntriesLen);
4382
4383 /** @brief Command description for GetCalendarCancellation
4384  *
4385  * Command: GetCalendarCancellation
4386  * @param providerId INT32U
4387  * @param issuerCalendarId INT32U
4388  * @param calendarType CalendarType
4389  */
4390 #define emberAfFillCommandCalendarClusterGetCalendarCancellation(providerId, issuerCalendarId, calendarType)                       \
4391     emberAfFillExternalBuffer(mask,                                                                                                \
4392                                                                                                                                    \
4393                               ZCL_GET_CALENDAR_CANCELLATION_COMMAND_ID, "uuu", providerId, issuerCalendarId, calendarType);
4394
4395 /** @brief Command description for GetChangeOfTenancy
4396  *
4397  * Command: GetChangeOfTenancy
4398  * @param providerId INT32U
4399  * @param issuerEventId INT32U
4400  * @param tariffType TariffType
4401  * @param implementationDateTime UTC_TIME
4402  * @param proposedTenancyChangeControl ProposedChangeControl
4403  */
4404 #define emberAfFillCommandDevice                                                                                                   \
4405     ManagementClusterGetChangeOfTenancy(providerId, issuerEventId, tariffType, implementationDateTime,                             \
4406                                         proposedTenancyChangeControl)                                                              \
4407         emberAfFillExternalBuffer(mask,                                                                                            \
4408                                                                                                                                    \
4409                                   ZCL_GET_CHANGE_OF_TENANCY_COMMAND_ID, "uuuuu", providerId, issuerEventId, tariffType,            \
4410                                   implementationDateTime, proposedTenancyChangeControl);
4411
4412 /** @brief Command description for GetChangeOfSupplier
4413  *
4414  * Command: GetChangeOfSupplier
4415  * @param currentProviderId INT32U
4416  * @param issuerEventId INT32U
4417  * @param tariffType TariffType
4418  * @param proposedProviderId INT32U
4419  * @param providerChangeImplementationTime UTC_TIME
4420  * @param providerChangeControl ProposedChangeControl
4421  * @param proposedProviderName OCTET_STRING
4422  * @param proposedProviderContactDetails OCTET_STRING
4423  */
4424 #define emberAfFillCommandDevice                                                                                                   \
4425     ManagementClusterGetChangeOfSupplier(currentProviderId, issuerEventId, tariffType, proposedProviderId,                         \
4426                                          providerChangeImplementationTime, providerChangeControl, proposedProviderName,            \
4427                                          proposedProviderContactDetails)                                                           \
4428         emberAfFillExternalBuffer(mask,                                                                                            \
4429                                                                                                                                    \
4430                                   ZCL_GET_CHANGE_OF_SUPPLIER_COMMAND_ID, "uuuuuuuu", currentProviderId, issuerEventId, tariffType, \
4431                                   proposedProviderId, providerChangeImplementationTime, providerChangeControl,                     \
4432                                   proposedProviderName, proposedProviderContactDetails);
4433
4434 /** @brief Command description for RequestNewPassword
4435  *
4436  * Command: RequestNewPassword
4437  * @param passwordType PasswordType
4438  * @param issuerEventId INT32U
4439  * @param implementationDateTime UTC_TIME
4440  * @param durationInMinutes INT16U
4441  * @param passwordType PasswordType
4442  * @param password OCTET_STRING
4443  */
4444 #define emberAfFillCommandDevice                                                                                                   \
4445     ManagementClusterRequestNewPassword(passwordType, issuerEventId, implementationDateTime, durationInMinutes, passwordType,      \
4446                                         password)                                                                                  \
4447         emberAfFillExternalBuffer(mask,                                                                                            \
4448                                                                                                                                    \
4449                                   ZCL_REQUEST_NEW_PASSWORD_COMMAND_ID, "uuuuuu", passwordType, issuerEventId,                      \
4450                                   implementationDateTime, durationInMinutes, passwordType, password);
4451
4452 /** @brief Command description for GetSiteId
4453  *
4454  * Command: GetSiteId
4455  * @param issuerEventId INT32U
4456  * @param siteIdTime UTC_TIME
4457  * @param providerId INT32U
4458  * @param siteId OCTET_STRING
4459  */
4460 #define emberAfFillCommandDevice                                                                                                   \
4461     ManagementClusterGetSiteId(issuerEventId, siteIdTime, providerId, siteId)                                                      \
4462         emberAfFillExternalBuffer(mask,                                                                                            \
4463                                                                                                                                    \
4464                                   ZCL_GET_SITE_ID_COMMAND_ID, "uuuu", issuerEventId, siteIdTime, providerId, siteId);
4465
4466 /** @brief Command description for ReportEventConfiguration
4467  *
4468  * Command: ReportEventConfiguration
4469  * @param commandIndex INT8U
4470  * @param issuerEventId INT32U
4471  * @param totalCommands INT8U
4472  * @param startDateTime UTC_TIME
4473  * @param eventConfigurationPayload EventConfigurationPayload []
4474  * @param eventConfigurationPayloadLen int
4475  * @param eventConfiguration EventConfiguration
4476  * @param configurationControl EventConfigurationControl
4477  * @param eventConfigurationPayload INT8U []
4478  * @param eventConfigurationPayloadLen int
4479  */
4480 #define emberAfFillCommandDevice                                                                                                   \
4481     ManagementClusterReportEventConfiguration(commandIndex, issuerEventId, totalCommands, startDateTime,                           \
4482                                               eventConfigurationPayload, eventConfigurationPayloadLen, eventConfiguration,         \
4483                                               configurationControl, eventConfigurationPayload, eventConfigurationPayloadLen)       \
4484         emberAfFillExternalBuffer(mask,                                                                                            \
4485                                                                                                                                    \
4486                                   ZCL_REPORT_EVENT_CONFIGURATION_COMMAND_ID, "uuuubuub", commandIndex, issuerEventId,              \
4487                                   totalCommands, startDateTime, eventConfigurationPayload, eventConfigurationPayloadLen,           \
4488                                   eventConfiguration, configurationControl, eventConfigurationPayload,                             \
4489                                   eventConfigurationPayloadLen);
4490
4491 /** @brief Command description for GetCIN
4492  *
4493  * Command: GetCIN
4494  * @param eventId INT16U
4495  */
4496 #define emberAfFillCommandDevice                                                                                                   \
4497     ManagementClusterGetCIN(eventId) emberAfFillExternalBuffer(mask,                                                               \
4498                                                                                                                                    \
4499                                                                ZCL_GET_CIN_COMMAND_ID, "u", eventId);
4500
4501 /** @brief Command description for UpdateCIN
4502  *
4503  * Command: UpdateCIN
4504  * @param issuerEventId INT32U
4505  * @param implementationTime UTC_TIME
4506  * @param providerId INT32U
4507  * @param customerIdNumber OCTET_STRING
4508  */
4509 #define emberAfFillCommandDevice                                                                                                   \
4510     ManagementClusterUpdateCIN(issuerEventId, implementationTime, providerId, customerIdNumber) emberAfFillExternalBuffer(         \
4511         mask,                                                                                                                      \
4512                                                                                                                                    \
4513         ZCL_UPDATE_CIN_COMMAND_ID, "uuuu", issuerEventId, implementationTime, providerId, customerIdNumber);
4514
4515 /** @brief Command description for GetEventLog
4516  *
4517  * Command: GetEventLog
4518  * @param eventControlLogId EventControlLogId
4519  * @param logId EventLogId
4520  * @param eventId INT16U
4521  * @param eventId INT16U
4522  * @param startTime UTC_TIME
4523  * @param eventTime UTC_TIME
4524  * @param endTime UTC_TIME
4525  * @param eventControl EventActionControl
4526  * @param numberOfEvents INT8U
4527  * @param eventData OCTET_STRING
4528  * @param eventOffset INT16U
4529  */
4530 #define emberAfFillCommandEventsClusterGetEventLog(eventControlLogId, logId, eventId, eventId, startTime, eventTime, endTime,      \
4531                                                    eventControl, numberOfEvents, eventData, eventOffset)                           \
4532     emberAfFillExternalBuffer(mask,                                                                                                \
4533                                                                                                                                    \
4534                               ZCL_GET_EVENT_LOG_COMMAND_ID, "uuuuuuuuuuu", eventControlLogId, logId, eventId, eventId, startTime,  \
4535                               eventTime, endTime, eventControl, numberOfEvents, eventData, eventOffset);
4536
4537 /** @brief Command description for ClearEventLogRequest
4538  *
4539  * Command: ClearEventLogRequest
4540  * @param logId EventLogId
4541  * @param totalNumberOfEvents INT16U
4542  * @param commandIndex INT8U
4543  * @param totalCommands INT8U
4544  * @param logPayloadControl NumberOfEventsLogPayloadControl
4545  * @param logPayload EventLogPayload []
4546  * @param logPayloadLen int
4547  */
4548 #define emberAfFillCommandEventsClusterClearEventLogRequest(logId, totalNumberOfEvents, commandIndex, totalCommands,               \
4549                                                             logPayloadControl, logPayload, logPayloadLen)                          \
4550     emberAfFillExternalBuffer(mask,                                                                                                \
4551                                                                                                                                    \
4552                               ZCL_CLEAR_EVENT_LOG_REQUEST_COMMAND_ID, "uuuuub", logId, totalNumberOfEvents, commandIndex,          \
4553                               totalCommands, logPayloadControl, logPayload, logPayloadLen);
4554
4555 /** @brief Command description for ClearEventLogResponse
4556  *
4557  * Command: ClearEventLogResponse
4558  * @param clearedEventsLogs ClearedEventsLogs
4559  */
4560 #define emberAfFillCommandEventsClusterClearEventLogResponse(clearedEventsLogs)                                                    \
4561     emberAfFillExternalBuffer(mask,                                                                                                \
4562                                                                                                                                    \
4563                               ZCL_CLEAR_EVENT_LOG_RESPONSE_COMMAND_ID, "u", clearedEventsLogs);
4564
4565 /** @brief Command description for PairingResponse
4566  *
4567  * Command: PairingResponse
4568  * @param pairingInformationVersion INT32U
4569  * @param localPairingInformationVersion INT32U
4570  * @param totalNumberOfDevices INT8U
4571  * @param eui64OfRequestingDevice IEEE_ADDRESS
4572  * @param commandIndex INT8U
4573  * @param totalNumberOfCommands INT8U
4574  * @param eui64s IEEE_ADDRESS []
4575  * @param eui64sLen int
4576  */
4577 #define emberAfFillCommandMDU                                                                                                      \
4578     PairingClusterPairingResponse(pairingInformationVersion, localPairingInformationVersion, totalNumberOfDevices,                 \
4579                                   eui64OfRequestingDevice, commandIndex, totalNumberOfCommands, eui64s, eui64sLen)                 \
4580         emberAfFillExternalBuffer(mask,                                                                                            \
4581                                                                                                                                    \
4582                                   ZCL_PAIRING_RESPONSE_COMMAND_ID, "uuuuuub", pairingInformationVersion,                           \
4583                                   localPairingInformationVersion, totalNumberOfDevices, eui64OfRequestingDevice, commandIndex,     \
4584                                   totalNumberOfCommands, eui64s, eui64sLen);
4585
4586 /** @brief Command description for GetSuspendZclMessagesStatus
4587  *
4588  * Command: GetSuspendZclMessagesStatus
4589  * @param period INT8U
4590  */
4591 #define emberAfFillCommandSub                                                                                                      \
4592     -GHzClusterGetSuspendZclMessagesStatus(period)                                                                                 \
4593         emberAfFillExternalBuffer(mask,                                                                                            \
4594                                                                                                                                    \
4595                                   ZCL_GET_SUSPEND_ZCL_MESSAGES_STATUS_COMMAND_ID, "u", period);
4596
4597 /** @brief Command description for InitiateKeyEstablishmentRequest
4598  *
4599  * Command: InitiateKeyEstablishmentRequest
4600  * @param keyEstablishmentSuite BITMAP16
4601  * @param requestedKeyEstablishmentSuite BITMAP16
4602  * @param ephemeralDataGenerateTime INT8U
4603  * @param ephemeralDataGenerateTime INT8U
4604  * @param confirmKeyGenerateTime INT8U
4605  * @param confirmKeyGenerateTime INT8U
4606  * @param identity Identity
4607  * @param identity Identity
4608  */
4609 #define emberAfFillCommandKey                                                                                                      \
4610     EstablishmentClusterInitiateKeyEstablishmentRequest(keyEstablishmentSuite, requestedKeyEstablishmentSuite,                     \
4611                                                         ephemeralDataGenerateTime, ephemeralDataGenerateTime,                      \
4612                                                         confirmKeyGenerateTime, confirmKeyGenerateTime, identity, identity)        \
4613         emberAfFillExternalBuffer(mask,                                                                                            \
4614                                                                                                                                    \
4615                                   ZCL_INITIATE_KEY_ESTABLISHMENT_REQUEST_COMMAND_ID, "uuuuuuuu", keyEstablishmentSuite,            \
4616                                   requestedKeyEstablishmentSuite, ephemeralDataGenerateTime, ephemeralDataGenerateTime,            \
4617                                   confirmKeyGenerateTime, confirmKeyGenerateTime, identity, identity);
4618
4619 /** @brief Command description for EphemeralDataRequest
4620  *
4621  * Command: EphemeralDataRequest
4622  * @param ephemeralData EphemeralData
4623  * @param ephemeralData EphemeralData
4624  */
4625 #define emberAfFillCommandKey                                                                                                      \
4626     EstablishmentClusterEphemeralDataRequest(ephemeralData, ephemeralData)                                                         \
4627         emberAfFillExternalBuffer(mask,                                                                                            \
4628                                                                                                                                    \
4629                                   ZCL_EPHEMERAL_DATA_REQUEST_COMMAND_ID, "uu", ephemeralData, ephemeralData);
4630
4631 /** @brief Command description for ConfirmKeyDataRequest
4632  *
4633  * Command: ConfirmKeyDataRequest
4634  * @param secureMessageAuthenticationCode Smac
4635  * @param secureMessageAuthenticationCode Smac
4636  */
4637 #define emberAfFillCommandKey                                                                                                      \
4638     EstablishmentClusterConfirmKeyDataRequest(secureMessageAuthenticationCode, secureMessageAuthenticationCode)                    \
4639         emberAfFillExternalBuffer(mask,                                                                                            \
4640                                                                                                                                    \
4641                                   ZCL_CONFIRM_KEY_DATA_REQUEST_COMMAND_ID, "uu", secureMessageAuthenticationCode,                  \
4642                                   secureMessageAuthenticationCode);
4643
4644 /** @brief Command description for TerminateKeyEstablishment
4645  *
4646  * Command: TerminateKeyEstablishment
4647  * @param statusCode AmiKeyEstablishmentStatus
4648  * @param waitTime INT8U
4649  * @param keyEstablishmentSuite BITMAP16
4650  */
4651 #define emberAfFillCommandKey                                                                                                      \
4652     EstablishmentClusterTerminateKeyEstablishment(statusCode, waitTime, keyEstablishmentSuite)                                     \
4653         emberAfFillExternalBuffer(mask,                                                                                            \
4654                                                                                                                                    \
4655                                   ZCL_TERMINATE_KEY_ESTABLISHMENT_COMMAND_ID, "uuu", statusCode, waitTime, keyEstablishmentSuite);
4656
4657 /** @brief Command description for RequestInformation
4658  *
4659  * Command: RequestInformation
4660  * @param inquiryId ENUM8
4661  * @param number INT8U
4662  * @param dataTypeId BITMAP8
4663  * @param buffer INT8U []
4664  * @param bufferLen int
4665  * @param requestInformationPayload INT8U []
4666  * @param requestInformationPayloadLen int
4667  */
4668 #define emberAfFillCommandInformationClusterRequestInformation(inquiryId, number, dataTypeId, buffer, bufferLen,                   \
4669                                                                requestInformationPayload, requestInformationPayloadLen)            \
4670     emberAfFillExternalBuffer(mask,                                                                                                \
4671                                                                                                                                    \
4672                               ZCL_REQUEST_INFORMATION_COMMAND_ID, "uuubb", inquiryId, number, dataTypeId, buffer, bufferLen,       \
4673                               requestInformationPayload, requestInformationPayloadLen);
4674
4675 /** @brief Command description for PushInformationResponse
4676  *
4677  * Command: PushInformationResponse
4678  * @param notificationList Notification []
4679  * @param notificationListLen int
4680  * @param contents INT8U []
4681  * @param contentsLen int
4682  */
4683 #define emberAfFillCommandInformationClusterPushInformationResponse(notificationList, notificationListLen, contents, contentsLen)  \
4684     emberAfFillExternalBuffer(mask,                                                                                                \
4685                                                                                                                                    \
4686                               ZCL_PUSH_INFORMATION_RESPONSE_COMMAND_ID, "bb", notificationList, notificationListLen, contents,     \
4687                               contentsLen);
4688
4689 /** @brief Command description for SendPreference
4690  *
4691  * Command: SendPreference
4692  * @param preferenceType INT16U
4693  * @param statusFeedbackList Status []
4694  * @param statusFeedbackListLen int
4695  * @param preferencePayload INT8U []
4696  * @param preferencePayloadLen int
4697  */
4698 #define emberAfFillCommandInformationClusterSendPreference(preferenceType, statusFeedbackList, statusFeedbackListLen,              \
4699                                                            preferencePayload, preferencePayloadLen)                                \
4700     emberAfFillExternalBuffer(mask,                                                                                                \
4701                                                                                                                                    \
4702                               ZCL_SEND_PREFERENCE_COMMAND_ID, "ubb", preferenceType, statusFeedbackList, statusFeedbackListLen,    \
4703                               preferencePayload, preferencePayloadLen);
4704
4705 /** @brief Command description for ServerRequestPreference
4706  *
4707  * Command: ServerRequestPreference
4708  * @param statusFeedback Status
4709  * @param preferenceType INT16U
4710  * @param preferencePayload INT8U []
4711  * @param preferencePayloadLen int
4712  */
4713 #define emberAfFillCommandInformationClusterServerRequestPreference(statusFeedback, preferenceType, preferencePayload,             \
4714                                                                     preferencePayloadLen)                                          \
4715     emberAfFillExternalBuffer(mask,                                                                                                \
4716                                                                                                                                    \
4717                               ZCL_SERVER_REQUEST_PREFERENCE_COMMAND_ID, "uub", statusFeedback, preferenceType, preferencePayload,  \
4718                               preferencePayloadLen);
4719
4720 /** @brief Command description for Update
4721  *
4722  * Command: Update
4723  * @param accessControl ENUM8
4724  * @param statusFeedbackList Status []
4725  * @param statusFeedbackListLen int
4726  * @param option BITMAP8
4727  * @param contents INT8U []
4728  * @param contentsLen int
4729  */
4730 #define emberAfFillCommandInformationClusterUpdate(accessControl, statusFeedbackList, statusFeedbackListLen, option, contents,     \
4731                                                    contentsLen)                                                                    \
4732     emberAfFillExternalBuffer(mask,                                                                                                \
4733                                                                                                                                    \
4734                               ZCL_UPDATE_COMMAND_ID, "ubub", accessControl, statusFeedbackList, statusFeedbackListLen, option,     \
4735                               contents, contentsLen);
4736
4737 /** @brief Command description for Delete
4738  *
4739  * Command: Delete
4740  * @param deletionOptions BITMAP8
4741  * @param notificationList Notification []
4742  * @param notificationListLen int
4743  * @param contentIds INT16U []
4744  * @param contentIdsLen int
4745  */
4746 #define emberAfFillCommandInformationClusterDelete(deletionOptions, notificationList, notificationListLen, contentIds,             \
4747                                                    contentIdsLen)                                                                  \
4748     emberAfFillExternalBuffer(mask,                                                                                                \
4749                                                                                                                                    \
4750                               ZCL_DELETE_COMMAND_ID, "ubb", deletionOptions, notificationList, notificationListLen, contentIds,    \
4751                               contentIdsLen);
4752
4753 /** @brief Command description for ConfigureNodeDescription
4754  *
4755  * Command: ConfigureNodeDescription
4756  * @param description CHAR_STRING
4757  * @param notificationList Notification []
4758  * @param notificationListLen int
4759  */
4760 #define emberAfFillCommandInformationClusterConfigureNodeDescription(description, notificationList, notificationListLen)           \
4761     emberAfFillExternalBuffer(mask,                                                                                                \
4762                                                                                                                                    \
4763                               ZCL_CONFIGURE_NODE_DESCRIPTION_COMMAND_ID, "ub", description, notificationList,                      \
4764                               notificationListLen);
4765
4766 /** @brief Command description for ConfigureDeliveryEnable
4767  *
4768  * Command: ConfigureDeliveryEnable
4769  * @param enable BOOLEAN
4770  */
4771 #define emberAfFillCommandInformationClusterConfigureDeliveryEnable(enable)                                                        \
4772     emberAfFillExternalBuffer(mask,                                                                                                \
4773                                                                                                                                    \
4774                               ZCL_CONFIGURE_DELIVERY_ENABLE_COMMAND_ID, "u", enable);
4775
4776 /** @brief Command description for ConfigurePushInformationTimer
4777  *
4778  * Command: ConfigurePushInformationTimer
4779  * @param timer INT32U
4780  */
4781 #define emberAfFillCommandInformationClusterConfigurePushInformationTimer(timer)                                                   \
4782     emberAfFillExternalBuffer(mask,                                                                                                \
4783                                                                                                                                    \
4784                               ZCL_CONFIGURE_PUSH_INFORMATION_TIMER_COMMAND_ID, "u", timer);
4785
4786 /** @brief Command description for ConfigureSetRootId
4787  *
4788  * Command: ConfigureSetRootId
4789  * @param rootId INT16U
4790  */
4791 #define emberAfFillCommandInformationClusterConfigureSetRootId(rootId)                                                             \
4792     emberAfFillExternalBuffer(mask,                                                                                                \
4793                                                                                                                                    \
4794                               ZCL_CONFIGURE_SET_ROOT_ID_COMMAND_ID, "u", rootId);
4795
4796 /** @brief Command description for ReadFileRequest
4797  *
4798  * Command: ReadFileRequest
4799  * @param fileIndex INT16U
4800  * @param writeOptions BITMAP8
4801  * @param fileStartPositionAndRequestedOctetCount INT8U []
4802  * @param fileStartPositionAndRequestedOctetCountLen int
4803  * @param fileSize INT8U []
4804  * @param fileSizeLen int
4805  */
4806 #define emberAfFillCommandData                                                                                                     \
4807     SharingClusterReadFileRequest(fileIndex, writeOptions, fileStartPositionAndRequestedOctetCount,                                \
4808                                   fileStartPositionAndRequestedOctetCountLen, fileSize, fileSizeLen)                               \
4809         emberAfFillExternalBuffer(mask,                                                                                            \
4810                                                                                                                                    \
4811                                   ZCL_READ_FILE_REQUEST_COMMAND_ID, "uubb", fileIndex, writeOptions,                               \
4812                                   fileStartPositionAndRequestedOctetCount, fileStartPositionAndRequestedOctetCountLen, fileSize,   \
4813                                   fileSizeLen);
4814
4815 /** @brief Command description for ReadRecordRequest
4816  *
4817  * Command: ReadRecordRequest
4818  * @param fileIndex INT16U
4819  * @param fileIndex INT16U
4820  * @param fileStartRecordAndRequestedRecordCount INT8U []
4821  * @param fileStartRecordAndRequestedRecordCountLen int
4822  * @param fileStartPosition INT32U
4823  * @param octetCount INT32U
4824  */
4825 #define emberAfFillCommandData                                                                                                     \
4826     SharingClusterReadRecordRequest(fileIndex, fileIndex, fileStartRecordAndRequestedRecordCount,                                  \
4827                                     fileStartRecordAndRequestedRecordCountLen, fileStartPosition, octetCount)                      \
4828         emberAfFillExternalBuffer(mask,                                                                                            \
4829                                                                                                                                    \
4830                                   ZCL_READ_RECORD_REQUEST_COMMAND_ID, "uubuu", fileIndex, fileIndex,                               \
4831                                   fileStartRecordAndRequestedRecordCount, fileStartRecordAndRequestedRecordCountLen,               \
4832                                   fileStartPosition, octetCount);
4833
4834 /** @brief Command description for WriteFileResponse
4835  *
4836  * Command: WriteFileResponse
4837  * @param status ENUM8
4838  * @param fileIndex INT16U
4839  * @param fileIndex INT8U []
4840  * @param fileIndexLen int
4841  * @param fileStartRecord INT16U
4842  * @param recordCount INT16U
4843  */
4844 #define emberAfFillCommandData                                                                                                     \
4845     SharingClusterWriteFileResponse(status, fileIndex, fileIndex, fileIndexLen, fileStartRecord, recordCount)                      \
4846         emberAfFillExternalBuffer(mask,                                                                                            \
4847                                                                                                                                    \
4848                                   ZCL_WRITE_FILE_RESPONSE_COMMAND_ID, "uubuu", status, fileIndex, fileIndex, fileIndexLen,         \
4849                                   fileStartRecord, recordCount);
4850
4851 /** @brief Command description for FileTransmission
4852  *
4853  * Command: FileTransmission
4854  * @param transmitOptions BITMAP8
4855  * @param buffer INT8U []
4856  * @param bufferLen int
4857  */
4858 #define emberAfFillCommandData                                                                                                     \
4859     SharingClusterFileTransmission(transmitOptions, buffer, bufferLen)                                                             \
4860         emberAfFillExternalBuffer(mask,                                                                                            \
4861                                                                                                                                    \
4862                                   ZCL_FILE_TRANSMISSION_COMMAND_ID, "ub", transmitOptions, buffer, bufferLen);
4863
4864 /** @brief Command description for RecordTransmission
4865  *
4866  * Command: RecordTransmission
4867  * @param transmitOptions BITMAP8
4868  * @param buffer INT8U []
4869  * @param bufferLen int
4870  */
4871 #define emberAfFillCommandData                                                                                                     \
4872     SharingClusterRecordTransmission(transmitOptions, buffer, bufferLen)                                                           \
4873         emberAfFillExternalBuffer(mask,                                                                                            \
4874                                                                                                                                    \
4875                                   ZCL_RECORD_TRANSMISSION_COMMAND_ID, "ub", transmitOptions, buffer, bufferLen);
4876
4877 /** @brief Command description for SearchGame
4878  *
4879  * Command: SearchGame
4880  * @param specificGame ENUM8
4881  * @param gameId INT16U
4882  * @param gameId INT16U
4883  * @param gameMaster BOOLEAN
4884  * @param listOfGame CHAR_STRING
4885  */
4886 #define emberAfFillCommandGamingClusterSearchGame(specificGame, gameId, gameId, gameMaster, listOfGame)                            \
4887     emberAfFillExternalBuffer(mask,                                                                                                \
4888                                                                                                                                    \
4889                               ZCL_SEARCH_GAME_COMMAND_ID, "uuuuu", specificGame, gameId, gameId, gameMaster, listOfGame);
4890
4891 /** @brief Command description for JoinGame
4892  *
4893  * Command: JoinGame
4894  * @param gameId INT16U
4895  * @param commandId INT8U
4896  * @param joinAsMaster BOOLEAN
4897  * @param status BITMAP8
4898  * @param nameOfGame CHAR_STRING
4899  * @param message CHAR_STRING
4900  */
4901 #define emberAfFillCommandGamingClusterJoinGame(gameId, commandId, joinAsMaster, status, nameOfGame, message)                      \
4902     emberAfFillExternalBuffer(mask,                                                                                                \
4903                                                                                                                                    \
4904                               ZCL_JOIN_GAME_COMMAND_ID, "uuuuuu", gameId, commandId, joinAsMaster, status, nameOfGame, message);
4905
4906 /** @brief Command description for StartGame
4907  *
4908  * Command: StartGame
4909  */
4910 #define emberAfFillCommandGamingClusterStartGame()                                                                                 \
4911     emberAfFillExternalBuffer(mask,                                                                                                \
4912                                                                                                                                    \
4913                               ZCL_START_GAME_COMMAND_ID, "", );
4914
4915 /** @brief Command description for PauseGame
4916  *
4917  * Command: PauseGame
4918  */
4919 #define emberAfFillCommandGamingClusterPauseGame()                                                                                 \
4920     emberAfFillExternalBuffer(mask,                                                                                                \
4921                                                                                                                                    \
4922                               ZCL_PAUSE_GAME_COMMAND_ID, "", );
4923
4924 /** @brief Command description for ResumeGame
4925  *
4926  * Command: ResumeGame
4927  */
4928 #define emberAfFillCommandGamingClusterResumeGame()                                                                                \
4929     emberAfFillExternalBuffer(mask,                                                                                                \
4930                                                                                                                                    \
4931                               ZCL_RESUME_GAME_COMMAND_ID, "", );
4932
4933 /** @brief Command description for QuitGame
4934  *
4935  * Command: QuitGame
4936  */
4937 #define emberAfFillCommandGamingClusterQuitGame()                                                                                  \
4938     emberAfFillExternalBuffer(mask,                                                                                                \
4939                                                                                                                                    \
4940                               ZCL_QUIT_GAME_COMMAND_ID, "", );
4941
4942 /** @brief Command description for EndGame
4943  *
4944  * Command: EndGame
4945  */
4946 #define emberAfFillCommandGamingClusterEndGame()                                                                                   \
4947     emberAfFillExternalBuffer(mask,                                                                                                \
4948                                                                                                                                    \
4949                               ZCL_END_GAME_COMMAND_ID, "", );
4950
4951 /** @brief Command description for StartOver
4952  *
4953  * Command: StartOver
4954  */
4955 #define emberAfFillCommandGamingClusterStartOver()                                                                                 \
4956     emberAfFillExternalBuffer(mask,                                                                                                \
4957                                                                                                                                    \
4958                               ZCL_START_OVER_COMMAND_ID, "", );
4959
4960 /** @brief Command description for ActionControl
4961  *
4962  * Command: ActionControl
4963  * @param actions BITMAP32
4964  */
4965 #define emberAfFillCommandGamingClusterActionControl(actions)                                                                      \
4966     emberAfFillExternalBuffer(mask,                                                                                                \
4967                                                                                                                                    \
4968                               ZCL_ACTION_CONTROL_COMMAND_ID, "u", actions);
4969
4970 /** @brief Command description for DownloadGame
4971  *
4972  * Command: DownloadGame
4973  */
4974 #define emberAfFillCommandGamingClusterDownloadGame()                                                                              \
4975     emberAfFillExternalBuffer(mask,                                                                                                \
4976                                                                                                                                    \
4977                               ZCL_DOWNLOAD_GAME_COMMAND_ID, "", );
4978
4979 /** @brief Command description for PathCreation
4980  *
4981  * Command: PathCreation
4982  * @param originatorAddress DATA16
4983  * @param originatorAddress DATA16
4984  * @param destinationAddress DATA16
4985  * @param destinationAddress DATA16
4986  * @param dataRate INT8U
4987  * @param dataRate INT8U
4988  */
4989 #define emberAfFillCommandData                                                                                                     \
4990     Rate ControlClusterPathCreation(originatorAddress, originatorAddress, destinationAddress, destinationAddress, dataRate,        \
4991                                     dataRate)                                                                                      \
4992         emberAfFillExternalBuffer(mask,                                                                                            \
4993                                                                                                                                    \
4994                                   ZCL_PATH_CREATION_COMMAND_ID, "uuuuuu", originatorAddress, originatorAddress,                    \
4995                                   destinationAddress, destinationAddress, dataRate, dataRate);
4996
4997 /** @brief Command description for DataRateNotification
4998  *
4999  * Command: DataRateNotification
5000  * @param originatorAddress DATA16
5001  * @param destinationAddress DATA16
5002  * @param dataRate INT8U
5003  */
5004 #define emberAfFillCommandData                                                                                                     \
5005     Rate ControlClusterDataRateNotification(originatorAddress, destinationAddress, dataRate)                                       \
5006         emberAfFillExternalBuffer(mask,                                                                                            \
5007                                                                                                                                    \
5008                                   ZCL_DATA_RATE_NOTIFICATION_COMMAND_ID, "uuu", originatorAddress, destinationAddress, dataRate);
5009
5010 /** @brief Command description for PathDeletion
5011  *
5012  * Command: PathDeletion
5013  * @param originatorAddress DATA16
5014  * @param destinationAddress DATA16
5015  */
5016 #define emberAfFillCommandData                                                                                                     \
5017     Rate ControlClusterPathDeletion(originatorAddress, destinationAddress)                                                         \
5018         emberAfFillExternalBuffer(mask,                                                                                            \
5019                                                                                                                                    \
5020                                   ZCL_PATH_DELETION_COMMAND_ID, "uu", originatorAddress, destinationAddress);
5021
5022 /** @brief Command description for EstablishmentRequest
5023  *
5024  * Command: EstablishmentRequest
5025  * @param flag BITMAP8
5026  * @param ackNack ENUM8
5027  * @param codecType ENUM8
5028  * @param codecType ENUM8
5029  * @param sampFreq ENUM8
5030  * @param codecRate ENUM8
5031  * @param serviceType ENUM8
5032  * @param buffer INT8U []
5033  * @param bufferLen int
5034  */
5035 #define emberAfFillCommandVoice                                                                                                    \
5036     over ZigBeeClusterEstablishmentRequest(flag, ackNack, codecType, codecType, sampFreq, codecRate, serviceType, buffer,          \
5037                                            bufferLen)                                                                              \
5038         emberAfFillExternalBuffer(mask,                                                                                            \
5039                                                                                                                                    \
5040                                   ZCL_ESTABLISHMENT_REQUEST_COMMAND_ID, "uuuuuuub", flag, ackNack, codecType, codecType, sampFreq, \
5041                                   codecRate, serviceType, buffer, bufferLen);
5042
5043 /** @brief Command description for VoiceTransmission
5044  *
5045  * Command: VoiceTransmission
5046  * @param voiceData INT8U []
5047  * @param voiceDataLen int
5048  * @param sequenceNumber INT8U
5049  * @param errorFlag ENUM8
5050  */
5051 #define emberAfFillCommandVoice                                                                                                    \
5052     over ZigBeeClusterVoiceTransmission(voiceData, voiceDataLen, sequenceNumber, errorFlag)                                        \
5053         emberAfFillExternalBuffer(mask,                                                                                            \
5054                                                                                                                                    \
5055                                   ZCL_VOICE_TRANSMISSION_COMMAND_ID, "buu", voiceData, voiceDataLen, sequenceNumber, errorFlag);
5056
5057 /** @brief Command description for VoiceTransmissionCompletion
5058  *
5059  * Command: VoiceTransmissionCompletion
5060  * @param controlType ENUM8
5061  */
5062 #define emberAfFillCommandVoice                                                                                                    \
5063     over ZigBeeClusterVoiceTransmissionCompletion(controlType)                                                                     \
5064         emberAfFillExternalBuffer(mask,                                                                                            \
5065                                                                                                                                    \
5066                                   ZCL_VOICE_TRANSMISSION_COMPLETION_COMMAND_ID, "u", controlType);
5067
5068 /** @brief Command description for ControlResponse
5069  *
5070  * Command: ControlResponse
5071  * @param ackNack ENUM8
5072  */
5073 #define emberAfFillCommandVoice                                                                                                    \
5074     over ZigBeeClusterControlResponse(ackNack) emberAfFillExternalBuffer(mask,                                                     \
5075                                                                                                                                    \
5076                                                                          ZCL_CONTROL_RESPONSE_COMMAND_ID, "u", ackNack);
5077
5078 /** @brief Command description for JoinChatRequest
5079  *
5080  * Command: JoinChatRequest
5081  * @param uid INT16U
5082  * @param status ENUM8
5083  * @param nickname CHAR_STRING
5084  * @param cid INT16U
5085  * @param cid INT16U
5086  */
5087 #define emberAfFillCommandChattingClusterJoinChatRequest(uid, status, nickname, cid, cid)                                          \
5088     emberAfFillExternalBuffer(mask,                                                                                                \
5089                                                                                                                                    \
5090                               ZCL_JOIN_CHAT_REQUEST_COMMAND_ID, "uuuuu", uid, status, nickname, cid, cid);
5091
5092 /** @brief Command description for LeaveChatRequest
5093  *
5094  * Command: LeaveChatRequest
5095  * @param cid INT16U
5096  * @param status ENUM8
5097  * @param uid INT16U
5098  * @param cid INT16U
5099  * @param chatParticipantList ChatParticipant []
5100  * @param chatParticipantListLen int
5101  */
5102 #define emberAfFillCommandChattingClusterLeaveChatRequest(cid, status, uid, cid, chatParticipantList, chatParticipantListLen)      \
5103     emberAfFillExternalBuffer(mask,                                                                                                \
5104                                                                                                                                    \
5105                               ZCL_LEAVE_CHAT_REQUEST_COMMAND_ID, "uuuub", cid, status, uid, cid, chatParticipantList,              \
5106                               chatParticipantListLen);
5107
5108 /** @brief Command description for SearchChatRequest
5109  *
5110  * Command: SearchChatRequest
5111  * @param cid INT16U
5112  * @param uid INT16U
5113  * @param nickname CHAR_STRING
5114  */
5115 #define emberAfFillCommandChattingClusterSearchChatRequest(cid, uid, nickname)                                                     \
5116     emberAfFillExternalBuffer(mask,                                                                                                \
5117                                                                                                                                    \
5118                               ZCL_SEARCH_CHAT_REQUEST_COMMAND_ID, "uuu", cid, uid, nickname);
5119
5120 /** @brief Command description for SwitchChairmanResponse
5121  *
5122  * Command: SwitchChairmanResponse
5123  * @param cid INT16U
5124  * @param cid INT16U
5125  * @param uid INT16U
5126  * @param uid INT16U
5127  * @param nickname CHAR_STRING
5128  */
5129 #define emberAfFillCommandChattingClusterSwitchChairmanResponse(cid, cid, uid, uid, nickname)                                      \
5130     emberAfFillExternalBuffer(mask,                                                                                                \
5131                                                                                                                                    \
5132                               ZCL_SWITCH_CHAIRMAN_RESPONSE_COMMAND_ID, "uuuuu", cid, cid, uid, uid, nickname);
5133
5134 /** @brief Command description for StartChatRequest
5135  *
5136  * Command: StartChatRequest
5137  * @param name CHAR_STRING
5138  * @param options BITMAP8
5139  * @param uid INT16U
5140  * @param chatRoomList ChatRoom []
5141  * @param chatRoomListLen int
5142  * @param nickname CHAR_STRING
5143  */
5144 #define emberAfFillCommandChattingClusterStartChatRequest(name, options, uid, chatRoomList, chatRoomListLen, nickname)             \
5145     emberAfFillExternalBuffer(mask,                                                                                                \
5146                                                                                                                                    \
5147                               ZCL_START_CHAT_REQUEST_COMMAND_ID, "uuubu", name, options, uid, chatRoomList, chatRoomListLen,       \
5148                               nickname);
5149
5150 /** @brief Command description for ChatMessage
5151  *
5152  * Command: ChatMessage
5153  * @param destinationUid INT16U
5154  * @param cid INT16U
5155  * @param sourceUid INT16U
5156  * @param cid INT16U
5157  * @param nickname CHAR_STRING
5158  * @param message CHAR_STRING
5159  */
5160 #define emberAfFillCommandChattingClusterChatMessage(destinationUid, cid, sourceUid, cid, nickname, message)                       \
5161     emberAfFillExternalBuffer(mask,                                                                                                \
5162                                                                                                                                    \
5163                               ZCL_CHAT_MESSAGE_COMMAND_ID, "uuuuuu", destinationUid, cid, sourceUid, cid, nickname, message);
5164
5165 /** @brief Command description for GetNodeInformationRequest
5166  *
5167  * Command: GetNodeInformationRequest
5168  * @param cid INT16U
5169  * @param cid INT16U
5170  * @param uid INT16U
5171  * @param nodeInformationList NodeInformation []
5172  * @param nodeInformationListLen int
5173  */
5174 #define emberAfFillCommandChattingClusterGetNodeInformationRequest(cid, cid, uid, nodeInformationList, nodeInformationListLen)     \
5175     emberAfFillExternalBuffer(mask,                                                                                                \
5176                                                                                                                                    \
5177                               ZCL_GET_NODE_INFORMATION_REQUEST_COMMAND_ID, "uuub", cid, cid, uid, nodeInformationList,             \
5178                               nodeInformationListLen);
5179
5180 /** @brief Command description for SwitchChairmanNotification
5181  *
5182  * Command: SwitchChairmanNotification
5183  * @param cid INT16U
5184  * @param uid INT16U
5185  * @param address DATA16
5186  * @param endpoint INT8U
5187  */
5188 #define emberAfFillCommandChattingClusterSwitchChairmanNotification(cid, uid, address, endpoint)                                   \
5189     emberAfFillExternalBuffer(mask,                                                                                                \
5190                                                                                                                                    \
5191                               ZCL_SWITCH_CHAIRMAN_NOTIFICATION_COMMAND_ID, "uuuu", cid, uid, address, endpoint);
5192
5193 /** @brief Command description for GetNodeInformationResponse
5194  *
5195  * Command: GetNodeInformationResponse
5196  * @param status ENUM8
5197  * @param cid INT16U
5198  * @param uid INT16U
5199  * @param addressEndpointAndNickname INT8U []
5200  * @param addressEndpointAndNicknameLen int
5201  */
5202 #define emberAfFillCommandChattingClusterGetNodeInformationResponse(status, cid, uid, addressEndpointAndNickname,                  \
5203                                                                     addressEndpointAndNicknameLen)                                 \
5204     emberAfFillExternalBuffer(mask,                                                                                                \
5205                                                                                                                                    \
5206                               ZCL_GET_NODE_INFORMATION_RESPONSE_COMMAND_ID, "uuub", status, cid, uid, addressEndpointAndNickname,  \
5207                               addressEndpointAndNicknameLen);
5208
5209 /** @brief Command description for BuyRequest
5210  *
5211  * Command: BuyRequest
5212  * @param userId OCTET_STRING
5213  * @param serialNumber OCTET_STRING
5214  * @param userType INT16U
5215  * @param currency INT32U
5216  * @param serviceId INT16U
5217  * @param priceTrailingDigit INT8U
5218  * @param goodId OCTET_STRING
5219  * @param price INT32U
5220  * @param timestamp OCTET_STRING
5221  * @param transId INT16U
5222  * @param transStatus ENUM8
5223  */
5224 #define emberAfFillCommandPaymentClusterBuyRequest(userId, serialNumber, userType, currency, serviceId, priceTrailingDigit,        \
5225                                                    goodId, price, timestamp, transId, transStatus)                                 \
5226     emberAfFillExternalBuffer(mask,                                                                                                \
5227                                                                                                                                    \
5228                               ZCL_BUY_REQUEST_COMMAND_ID, "uuuuuuuuuuu", userId, serialNumber, userType, currency, serviceId,      \
5229                               priceTrailingDigit, goodId, price, timestamp, transId, transStatus);
5230
5231 /** @brief Command description for AcceptPayment
5232  *
5233  * Command: AcceptPayment
5234  * @param userId OCTET_STRING
5235  * @param serialNumber OCTET_STRING
5236  * @param userType INT16U
5237  * @param currency INT32U
5238  * @param serviceId INT16U
5239  * @param priceTrailingDigit INT8U
5240  * @param goodId OCTET_STRING
5241  * @param price INT32U
5242  * @param timestamp OCTET_STRING
5243  */
5244 #define emberAfFillCommandPaymentClusterAcceptPayment(userId, serialNumber, userType, currency, serviceId, priceTrailingDigit,     \
5245                                                       goodId, price, timestamp)                                                    \
5246     emberAfFillExternalBuffer(mask,                                                                                                \
5247                                                                                                                                    \
5248                               ZCL_ACCEPT_PAYMENT_COMMAND_ID, "uuuuuuuuu", userId, serialNumber, userType, currency, serviceId,     \
5249                               priceTrailingDigit, goodId, price, timestamp);
5250
5251 /** @brief Command description for PaymentConfirm
5252  *
5253  * Command: PaymentConfirm
5254  * @param serialNumber OCTET_STRING
5255  * @param serialNumber OCTET_STRING
5256  * @param transId INT16U
5257  * @param status ENUM8
5258  * @param transStatus ENUM8
5259  */
5260 #define emberAfFillCommandPaymentClusterPaymentConfirm(serialNumber, serialNumber, transId, status, transStatus)                   \
5261     emberAfFillExternalBuffer(mask,                                                                                                \
5262                                                                                                                                    \
5263                               ZCL_PAYMENT_CONFIRM_COMMAND_ID, "uuuuu", serialNumber, serialNumber, transId, status, transStatus);
5264
5265 /** @brief Command description for Subscribe
5266  *
5267  * Command: Subscribe
5268  * @param userId OCTET_STRING
5269  * @param userId OCTET_STRING
5270  * @param serviceId INT16U
5271  * @param serviceId INT16U
5272  * @param serviceProviderId INT16U
5273  * @param serviceProviderId INT16U
5274  */
5275 #define emberAfFillCommandBillingClusterSubscribe(userId, userId, serviceId, serviceId, serviceProviderId, serviceProviderId)      \
5276     emberAfFillExternalBuffer(mask,                                                                                                \
5277                                                                                                                                    \
5278                               ZCL_SUBSCRIBE_COMMAND_ID, "uuuuuu", userId, userId, serviceId, serviceId, serviceProviderId,         \
5279                               serviceProviderId);
5280
5281 /** @brief Command description for Unsubscribe
5282  *
5283  * Command: Unsubscribe
5284  * @param userId OCTET_STRING
5285  * @param userId OCTET_STRING
5286  * @param serviceId INT16U
5287  * @param serviceId INT16U
5288  * @param serviceProviderId INT16U
5289  * @param serviceProviderId INT16U
5290  * @param timestamp OCTET_STRING
5291  * @param duration INT16U
5292  */
5293 #define emberAfFillCommandBillingClusterUnsubscribe(userId, userId, serviceId, serviceId, serviceProviderId, serviceProviderId,    \
5294                                                     timestamp, duration)                                                           \
5295     emberAfFillExternalBuffer(mask,                                                                                                \
5296                                                                                                                                    \
5297                               ZCL_UNSUBSCRIBE_COMMAND_ID, "uuuuuuuu", userId, userId, serviceId, serviceId, serviceProviderId,     \
5298                               serviceProviderId, timestamp, duration);
5299
5300 /** @brief Command description for StartBillingSession
5301  *
5302  * Command: StartBillingSession
5303  * @param userId OCTET_STRING
5304  * @param serviceId INT16U
5305  * @param serviceProviderId INT16U
5306  */
5307 #define emberAfFillCommandBillingClusterStartBillingSession(userId, serviceId, serviceProviderId)                                  \
5308     emberAfFillExternalBuffer(mask,                                                                                                \
5309                                                                                                                                    \
5310                               ZCL_START_BILLING_SESSION_COMMAND_ID, "uuu", userId, serviceId, serviceProviderId);
5311
5312 /** @brief Command description for StopBillingSession
5313  *
5314  * Command: StopBillingSession
5315  * @param userId OCTET_STRING
5316  * @param serviceId INT16U
5317  * @param serviceProviderId INT16U
5318  */
5319 #define emberAfFillCommandBillingClusterStopBillingSession(userId, serviceId, serviceProviderId)                                   \
5320     emberAfFillExternalBuffer(mask,                                                                                                \
5321                                                                                                                                    \
5322                               ZCL_STOP_BILLING_SESSION_COMMAND_ID, "uuu", userId, serviceId, serviceProviderId);
5323
5324 /** @brief Command description for BillStatusNotification
5325  *
5326  * Command: BillStatusNotification
5327  * @param userId OCTET_STRING
5328  * @param status ENUM8
5329  */
5330 #define emberAfFillCommandBillingClusterBillStatusNotification(userId, status)                                                     \
5331     emberAfFillExternalBuffer(mask,                                                                                                \
5332                                                                                                                                    \
5333                               ZCL_BILL_STATUS_NOTIFICATION_COMMAND_ID, "uu", userId, status);
5334
5335 /** @brief Command description for SessionKeepAlive
5336  *
5337  * Command: SessionKeepAlive
5338  * @param userId OCTET_STRING
5339  * @param serviceId INT16U
5340  * @param serviceProviderId INT16U
5341  */
5342 #define emberAfFillCommandBillingClusterSessionKeepAlive(userId, serviceId, serviceProviderId)                                     \
5343     emberAfFillExternalBuffer(mask,                                                                                                \
5344                                                                                                                                    \
5345                               ZCL_SESSION_KEEP_ALIVE_COMMAND_ID, "uuu", userId, serviceId, serviceProviderId);
5346
5347 /** @brief Command description for GetAlerts
5348  *
5349  * Command: GetAlerts
5350  * @param alertsCount AlertCount
5351  * @param alertStructures AlertStructure []
5352  * @param alertStructuresLen int
5353  */
5354 #define emberAfFillCommandAppliance                                                                                                \
5355     Events and AlertClusterGetAlerts(alertsCount, alertStructures, alertStructuresLen)                                             \
5356         emberAfFillExternalBuffer(mask,                                                                                            \
5357                                                                                                                                    \
5358                                   ZCL_GET_ALERTS_COMMAND_ID, "ub", alertsCount, alertStructures, alertStructuresLen);
5359
5360 /** @brief Command description for AlertsNotification
5361  *
5362  * Command: AlertsNotification
5363  * @param alertsCount AlertCount
5364  * @param alertStructures AlertStructure []
5365  * @param alertStructuresLen int
5366  */
5367 #define emberAfFillCommandAppliance                                                                                                \
5368     Events and AlertClusterAlertsNotification(alertsCount, alertStructures, alertStructuresLen)                                    \
5369         emberAfFillExternalBuffer(mask,                                                                                            \
5370                                                                                                                                    \
5371                                   ZCL_ALERTS_NOTIFICATION_COMMAND_ID, "ub", alertsCount, alertStructures, alertStructuresLen);
5372
5373 /** @brief Command description for EventsNotification
5374  *
5375  * Command: EventsNotification
5376  * @param eventHeader INT8U
5377  * @param eventId EventIdentification
5378  */
5379 #define emberAfFillCommandAppliance                                                                                                \
5380     Events and AlertClusterEventsNotification(eventHeader, eventId)                                                                \
5381         emberAfFillExternalBuffer(mask,                                                                                            \
5382                                                                                                                                    \
5383                                   ZCL_EVENTS_NOTIFICATION_COMMAND_ID, "uu", eventHeader, eventId);
5384
5385 /** @brief Command description for LogNotification
5386  *
5387  * Command: LogNotification
5388  * @param timeStamp TIME_OF_DAY
5389  * @param logId INT32U
5390  * @param logId INT32U
5391  * @param logLength INT32U
5392  * @param logPayload INT8U []
5393  * @param logPayloadLen int
5394  */
5395 #define emberAfFillCommandAppliance                                                                                                \
5396     StatisticsClusterLogNotification(timeStamp, logId, logId, logLength, logPayload, logPayloadLen) emberAfFillExternalBuffer(     \
5397         mask,                                                                                                                      \
5398                                                                                                                                    \
5399         ZCL_LOG_NOTIFICATION_COMMAND_ID, "uuuub", timeStamp, logId, logId, logLength, logPayload, logPayloadLen);
5400
5401 /** @brief Command description for LogQueueRequest
5402  *
5403  * Command: LogQueueRequest
5404  * @param timeStamp TIME_OF_DAY
5405  * @param logId INT32U
5406  * @param logLength INT32U
5407  * @param logPayload INT8U []
5408  * @param logPayloadLen int
5409  */
5410 #define emberAfFillCommandAppliance                                                                                                \
5411     StatisticsClusterLogQueueRequest(timeStamp, logId, logLength, logPayload, logPayloadLen) emberAfFillExternalBuffer(            \
5412         mask,                                                                                                                      \
5413                                                                                                                                    \
5414         ZCL_LOG_QUEUE_REQUEST_COMMAND_ID, "uuub", timeStamp, logId, logLength, logPayload, logPayloadLen);
5415
5416 /** @brief Command description for LogQueueResponse
5417  *
5418  * Command: LogQueueResponse
5419  * @param logQueueSize INT8U
5420  * @param logIds INT32U []
5421  * @param logIdsLen int
5422  */
5423 #define emberAfFillCommandAppliance                                                                                                \
5424     StatisticsClusterLogQueueResponse(logQueueSize, logIds, logIdsLen)                                                             \
5425         emberAfFillExternalBuffer(mask,                                                                                            \
5426                                                                                                                                    \
5427                                   ZCL_LOG_QUEUE_RESPONSE_COMMAND_ID, "ub", logQueueSize, logIds, logIdsLen);
5428
5429 /** @brief Command description for StatisticsAvailable
5430  *
5431  * Command: StatisticsAvailable
5432  * @param logQueueSize INT8U
5433  * @param logIds INT32U []
5434  * @param logIdsLen int
5435  */
5436 #define emberAfFillCommandAppliance                                                                                                \
5437     StatisticsClusterStatisticsAvailable(logQueueSize, logIds, logIdsLen)                                                          \
5438         emberAfFillExternalBuffer(mask,                                                                                            \
5439                                                                                                                                    \
5440                                   ZCL_STATISTICS_AVAILABLE_COMMAND_ID, "ub", logQueueSize, logIds, logIdsLen);
5441
5442 /** @brief Command description for GetProfileInfoCommand
5443  *
5444  * Command: GetProfileInfoCommand
5445  * @param profileCount INT8U
5446  * @param profileIntervalPeriod ENUM8
5447  * @param maxNumberOfIntervals INT8U
5448  * @param listOfAttributes INT16U []
5449  * @param listOfAttributesLen int
5450  */
5451 #define emberAfFillCommandElectrical                                                                                               \
5452     MeasurementClusterGetProfileInfoCommand(profileCount, profileIntervalPeriod, maxNumberOfIntervals, listOfAttributes,           \
5453                                             listOfAttributesLen)                                                                   \
5454         emberAfFillExternalBuffer(mask,                                                                                            \
5455                                                                                                                                    \
5456                                   ZCL_GET_PROFILE_INFO_COMMAND_COMMAND_ID, "uuub", profileCount, profileIntervalPeriod,            \
5457                                   maxNumberOfIntervals, listOfAttributes, listOfAttributesLen);
5458
5459 /** @brief Command description for GetMeasurementProfileResponseCommand
5460  *
5461  * Command: GetMeasurementProfileResponseCommand
5462  * @param startTime INT32U
5463  * @param attributeId INT16U
5464  * @param status ENUM8
5465  * @param startTime INT32U
5466  * @param profileIntervalPeriod ENUM8
5467  * @param numberOfIntervals ENUM8
5468  * @param numberOfIntervalsDelivered INT8U
5469  * @param attributeId INT16U
5470  * @param intervals INT8U []
5471  * @param intervalsLen int
5472  */
5473 #define emberAfFillCommandElectrical                                                                                               \
5474     MeasurementClusterGetMeasurementProfileResponseCommand(startTime, attributeId, status, startTime, profileIntervalPeriod,       \
5475                                                            numberOfIntervals, numberOfIntervalsDelivered, attributeId, intervals,  \
5476                                                            intervalsLen)                                                           \
5477         emberAfFillExternalBuffer(mask,                                                                                            \
5478                                                                                                                                    \
5479                                   ZCL_GET_MEASUREMENT_PROFILE_RESPONSE_COMMAND_COMMAND_ID, "uuuuuuuub", startTime, attributeId,    \
5480                                   status, startTime, profileIntervalPeriod, numberOfIntervals, numberOfIntervalsDelivered,         \
5481                                   attributeId, intervals, intervalsLen);
5482
5483 /** @brief Command description for ScanRequest
5484  *
5485  * Command: ScanRequest
5486  * @param transaction INT32U
5487  * @param zigbeeInformation ZigbeeInformation
5488  * @param zllInformation ZllInformation
5489  */
5490 #define emberAfFillCommandZLL                                                                                                      \
5491     CommissioningClusterScanRequest(transaction, zigbeeInformation, zllInformation)                                                \
5492         emberAfFillExternalBuffer(mask,                                                                                            \
5493                                                                                                                                    \
5494                                   ZCL_SCAN_REQUEST_COMMAND_ID, "uuu", transaction, zigbeeInformation, zllInformation);
5495
5496 /** @brief Command description for ScanResponse
5497  *
5498  * Command: ScanResponse
5499  * @param transaction INT32U
5500  * @param rssiCorrection INT8U
5501  * @param zigbeeInformation ZigbeeInformation
5502  * @param zllInformation ZllInformation
5503  * @param keyBitmask KeyBitmask
5504  * @param responseId INT32U
5505  * @param extendedPanId IEEE_ADDRESS
5506  * @param networkUpdateId INT8U
5507  * @param logicalChannel INT8U
5508  * @param panId INT16U
5509  * @param networkAddress INT16U
5510  * @param numberOfSubDevices INT8U
5511  * @param totalGroupIds INT8U
5512  * @param endpointId INT8U
5513  * @param profileId INT16U
5514  * @param deviceId INT16U
5515  * @param version INT8U
5516  * @param groupIdCount INT8U
5517  */
5518 #define emberAfFillCommandZLL                                                                                                      \
5519     CommissioningClusterScanResponse(transaction, rssiCorrection, zigbeeInformation, zllInformation, keyBitmask, responseId,       \
5520                                      extendedPanId, networkUpdateId, logicalChannel, panId, networkAddress, numberOfSubDevices,    \
5521                                      totalGroupIds, endpointId, profileId, deviceId, version, groupIdCount)                        \
5522         emberAfFillExternalBuffer(mask,                                                                                            \
5523                                                                                                                                    \
5524                                   ZCL_SCAN_RESPONSE_COMMAND_ID, "uuuuuuuuuuuuuuuuuu", transaction, rssiCorrection,                 \
5525                                   zigbeeInformation, zllInformation, keyBitmask, responseId, extendedPanId, networkUpdateId,       \
5526                                   logicalChannel, panId, networkAddress, numberOfSubDevices, totalGroupIds, endpointId, profileId, \
5527                                   deviceId, version, groupIdCount);
5528
5529 /** @brief Command description for DeviceInformationRequest
5530  *
5531  * Command: DeviceInformationRequest
5532  * @param transaction INT32U
5533  * @param startIndex INT8U
5534  */
5535 #define emberAfFillCommandZLL                                                                                                      \
5536     CommissioningClusterDeviceInformationRequest(transaction, startIndex)                                                          \
5537         emberAfFillExternalBuffer(mask,                                                                                            \
5538                                                                                                                                    \
5539                                   ZCL_DEVICE_INFORMATION_REQUEST_COMMAND_ID, "uu", transaction, startIndex);
5540
5541 /** @brief Command description for DeviceInformationResponse
5542  *
5543  * Command: DeviceInformationResponse
5544  * @param transaction INT32U
5545  * @param numberOfSubDevices INT8U
5546  * @param startIndex INT8U
5547  * @param deviceInformationRecordCount INT8U
5548  * @param deviceInformationRecordList DeviceInformationRecord []
5549  * @param deviceInformationRecordListLen int
5550  */
5551 #define emberAfFillCommandZLL                                                                                                      \
5552     CommissioningClusterDeviceInformationResponse(transaction, numberOfSubDevices, startIndex, deviceInformationRecordCount,       \
5553                                                   deviceInformationRecordList, deviceInformationRecordListLen)                     \
5554         emberAfFillExternalBuffer(mask,                                                                                            \
5555                                                                                                                                    \
5556                                   ZCL_DEVICE_INFORMATION_RESPONSE_COMMAND_ID, "uuuub", transaction, numberOfSubDevices,            \
5557                                   startIndex, deviceInformationRecordCount, deviceInformationRecordList,                           \
5558                                   deviceInformationRecordListLen);
5559
5560 /** @brief Command description for IdentifyRequest
5561  *
5562  * Command: IdentifyRequest
5563  * @param transaction INT32U
5564  * @param identifyDuration INT16U
5565  */
5566 #define emberAfFillCommandZLL                                                                                                      \
5567     CommissioningClusterIdentifyRequest(transaction, identifyDuration)                                                             \
5568         emberAfFillExternalBuffer(mask,                                                                                            \
5569                                                                                                                                    \
5570                                   ZCL_IDENTIFY_REQUEST_COMMAND_ID, "uu", transaction, identifyDuration);
5571
5572 /** @brief Command description for ResetToFactoryNewRequest
5573  *
5574  * Command: ResetToFactoryNewRequest
5575  * @param transaction INT32U
5576  */
5577 #define emberAfFillCommandZLL                                                                                                      \
5578     CommissioningClusterResetToFactoryNewRequest(transaction)                                                                      \
5579         emberAfFillExternalBuffer(mask,                                                                                            \
5580                                                                                                                                    \
5581                                   ZCL_RESET_TO_FACTORY_NEW_REQUEST_COMMAND_ID, "u", transaction);
5582
5583 /** @brief Command description for NetworkStartRequest
5584  *
5585  * Command: NetworkStartRequest
5586  * @param transaction INT32U
5587  * @param extendedPanId IEEE_ADDRESS
5588  * @param keyIndex KeyIndex
5589  * @param encryptedNetworkKey SECURITY_KEY
5590  * @param logicalChannel INT8U
5591  * @param panId INT16U
5592  * @param networkAddress INT16U
5593  * @param groupIdentifiersBegin INT16U
5594  * @param groupIdentifiersEnd INT16U
5595  * @param freeNetworkAddressRangeBegin INT16U
5596  * @param freeNetworkAddressRangeEnd INT16U
5597  * @param freeGroupIdentifierRangeBegin INT16U
5598  * @param freeGroupIdentifierRangeEnd INT16U
5599  * @param initiatorIeeeAddress IEEE_ADDRESS
5600  * @param initiatorNetworkAddress INT16U
5601  */
5602 #define emberAfFillCommandZLL                                                                                                      \
5603     CommissioningClusterNetworkStartRequest(                                                                                       \
5604         transaction, extendedPanId, keyIndex, encryptedNetworkKey, logicalChannel, panId, networkAddress, groupIdentifiersBegin,   \
5605         groupIdentifiersEnd, freeNetworkAddressRangeBegin, freeNetworkAddressRangeEnd, freeGroupIdentifierRangeBegin,              \
5606         freeGroupIdentifierRangeEnd, initiatorIeeeAddress, initiatorNetworkAddress)                                                \
5607         emberAfFillExternalBuffer(mask,                                                                                            \
5608                                                                                                                                    \
5609                                   ZCL_NETWORK_START_REQUEST_COMMAND_ID, "uuuuuuuuuuuuuuu", transaction, extendedPanId, keyIndex,   \
5610                                   encryptedNetworkKey, logicalChannel, panId, networkAddress, groupIdentifiersBegin,               \
5611                                   groupIdentifiersEnd, freeNetworkAddressRangeBegin, freeNetworkAddressRangeEnd,                   \
5612                                   freeGroupIdentifierRangeBegin, freeGroupIdentifierRangeEnd, initiatorIeeeAddress,                \
5613                                   initiatorNetworkAddress);
5614
5615 /** @brief Command description for NetworkStartResponse
5616  *
5617  * Command: NetworkStartResponse
5618  * @param transaction INT32U
5619  * @param status ZllStatus
5620  * @param extendedPanId IEEE_ADDRESS
5621  * @param networkUpdateId INT8U
5622  * @param logicalChannel INT8U
5623  * @param panId INT16U
5624  */
5625 #define emberAfFillCommandZLL                                                                                                      \
5626     CommissioningClusterNetworkStartResponse(transaction, status, extendedPanId, networkUpdateId, logicalChannel, panId)           \
5627         emberAfFillExternalBuffer(mask,                                                                                            \
5628                                                                                                                                    \
5629                                   ZCL_NETWORK_START_RESPONSE_COMMAND_ID, "uuuuuu", transaction, status, extendedPanId,             \
5630                                   networkUpdateId, logicalChannel, panId);
5631
5632 /** @brief Command description for NetworkJoinRouterRequest
5633  *
5634  * Command: NetworkJoinRouterRequest
5635  * @param transaction INT32U
5636  * @param extendedPanId IEEE_ADDRESS
5637  * @param keyIndex KeyIndex
5638  * @param encryptedNetworkKey SECURITY_KEY
5639  * @param networkUpdateId INT8U
5640  * @param logicalChannel INT8U
5641  * @param panId INT16U
5642  * @param networkAddress INT16U
5643  * @param groupIdentifiersBegin INT16U
5644  * @param groupIdentifiersEnd INT16U
5645  * @param freeNetworkAddressRangeBegin INT16U
5646  * @param freeNetworkAddressRangeEnd INT16U
5647  * @param freeGroupIdentifierRangeBegin INT16U
5648  * @param freeGroupIdentifierRangeEnd INT16U
5649  */
5650 #define emberAfFillCommandZLL                                                                                                      \
5651     CommissioningClusterNetworkJoinRouterRequest(transaction, extendedPanId, keyIndex, encryptedNetworkKey, networkUpdateId,       \
5652                                                  logicalChannel, panId, networkAddress, groupIdentifiersBegin,                     \
5653                                                  groupIdentifiersEnd, freeNetworkAddressRangeBegin, freeNetworkAddressRangeEnd,    \
5654                                                  freeGroupIdentifierRangeBegin, freeGroupIdentifierRangeEnd)                       \
5655         emberAfFillExternalBuffer(mask,                                                                                            \
5656                                                                                                                                    \
5657                                   ZCL_NETWORK_JOIN_ROUTER_REQUEST_COMMAND_ID, "uuuuuuuuuuuuuu", transaction, extendedPanId,        \
5658                                   keyIndex, encryptedNetworkKey, networkUpdateId, logicalChannel, panId, networkAddress,           \
5659                                   groupIdentifiersBegin, groupIdentifiersEnd, freeNetworkAddressRangeBegin,                        \
5660                                   freeNetworkAddressRangeEnd, freeGroupIdentifierRangeBegin, freeGroupIdentifierRangeEnd);
5661
5662 /** @brief Command description for NetworkJoinRouterResponse
5663  *
5664  * Command: NetworkJoinRouterResponse
5665  * @param transaction INT32U
5666  * @param status ZllStatus
5667  */
5668 #define emberAfFillCommandZLL                                                                                                      \
5669     CommissioningClusterNetworkJoinRouterResponse(transaction, status)                                                             \
5670         emberAfFillExternalBuffer(mask,                                                                                            \
5671                                                                                                                                    \
5672                                   ZCL_NETWORK_JOIN_ROUTER_RESPONSE_COMMAND_ID, "uu", transaction, status);
5673
5674 /** @brief Command description for NetworkJoinEndDeviceRequest
5675  *
5676  * Command: NetworkJoinEndDeviceRequest
5677  * @param transaction INT32U
5678  * @param extendedPanId IEEE_ADDRESS
5679  * @param keyIndex KeyIndex
5680  * @param encryptedNetworkKey SECURITY_KEY
5681  * @param networkUpdateId INT8U
5682  * @param logicalChannel INT8U
5683  * @param panId INT16U
5684  * @param networkAddress INT16U
5685  * @param groupIdentifiersBegin INT16U
5686  * @param groupIdentifiersEnd INT16U
5687  * @param freeNetworkAddressRangeBegin INT16U
5688  * @param freeNetworkAddressRangeEnd INT16U
5689  * @param freeGroupIdentifierRangeBegin INT16U
5690  * @param freeGroupIdentifierRangeEnd INT16U
5691  */
5692 #define emberAfFillCommandZLL                                                                                                      \
5693     CommissioningClusterNetworkJoinEndDeviceRequest(transaction, extendedPanId, keyIndex, encryptedNetworkKey, networkUpdateId,    \
5694                                                     logicalChannel, panId, networkAddress, groupIdentifiersBegin,                  \
5695                                                     groupIdentifiersEnd, freeNetworkAddressRangeBegin, freeNetworkAddressRangeEnd, \
5696                                                     freeGroupIdentifierRangeBegin, freeGroupIdentifierRangeEnd)                    \
5697         emberAfFillExternalBuffer(mask,                                                                                            \
5698                                                                                                                                    \
5699                                   ZCL_NETWORK_JOIN_END_DEVICE_REQUEST_COMMAND_ID, "uuuuuuuuuuuuuu", transaction, extendedPanId,    \
5700                                   keyIndex, encryptedNetworkKey, networkUpdateId, logicalChannel, panId, networkAddress,           \
5701                                   groupIdentifiersBegin, groupIdentifiersEnd, freeNetworkAddressRangeBegin,                        \
5702                                   freeNetworkAddressRangeEnd, freeGroupIdentifierRangeBegin, freeGroupIdentifierRangeEnd);
5703
5704 /** @brief Command description for NetworkJoinEndDeviceResponse
5705  *
5706  * Command: NetworkJoinEndDeviceResponse
5707  * @param transaction INT32U
5708  * @param status ZllStatus
5709  */
5710 #define emberAfFillCommandZLL                                                                                                      \
5711     CommissioningClusterNetworkJoinEndDeviceResponse(transaction, status)                                                          \
5712         emberAfFillExternalBuffer(mask,                                                                                            \
5713                                                                                                                                    \
5714                                   ZCL_NETWORK_JOIN_END_DEVICE_RESPONSE_COMMAND_ID, "uu", transaction, status);
5715
5716 /** @brief Command description for NetworkUpdateRequest
5717  *
5718  * Command: NetworkUpdateRequest
5719  * @param transaction INT32U
5720  * @param extendedPanId IEEE_ADDRESS
5721  * @param networkUpdateId INT8U
5722  * @param logicalChannel INT8U
5723  * @param panId INT16U
5724  * @param networkAddress INT16U
5725  */
5726 #define emberAfFillCommandZLL                                                                                                      \
5727     CommissioningClusterNetworkUpdateRequest(transaction, extendedPanId, networkUpdateId, logicalChannel, panId, networkAddress)   \
5728         emberAfFillExternalBuffer(mask,                                                                                            \
5729                                                                                                                                    \
5730                                   ZCL_NETWORK_UPDATE_REQUEST_COMMAND_ID, "uuuuuu", transaction, extendedPanId, networkUpdateId,    \
5731                                   logicalChannel, panId, networkAddress);
5732
5733 /** @brief Command description for EndpointInformation
5734  *
5735  * Command: EndpointInformation
5736  * @param ieeeAddress IEEE_ADDRESS
5737  * @param networkAddress INT16U
5738  * @param endpointId INT8U
5739  * @param profileId INT16U
5740  * @param deviceId INT16U
5741  * @param version INT8U
5742  */
5743 #define emberAfFillCommandZLL                                                                                                      \
5744     CommissioningClusterEndpointInformation(ieeeAddress, networkAddress, endpointId, profileId, deviceId, version)                 \
5745         emberAfFillExternalBuffer(mask,                                                                                            \
5746                                                                                                                                    \
5747                                   ZCL_ENDPOINT_INFORMATION_COMMAND_ID, "uuuuuu", ieeeAddress, networkAddress, endpointId,          \
5748                                   profileId, deviceId, version);
5749
5750 /** @brief Command description for GetGroupIdentifiersRequest
5751  *
5752  * Command: GetGroupIdentifiersRequest
5753  * @param startIndex INT8U
5754  * @param total INT8U
5755  * @param startIndex INT8U
5756  * @param count INT8U
5757  * @param groupInformationRecordList GroupInformationRecord []
5758  * @param groupInformationRecordListLen int
5759  */
5760 #define emberAfFillCommandZLL                                                                                                      \
5761     CommissioningClusterGetGroupIdentifiersRequest(startIndex, total, startIndex, count, groupInformationRecordList,               \
5762                                                    groupInformationRecordListLen)                                                  \
5763         emberAfFillExternalBuffer(mask,                                                                                            \
5764                                                                                                                                    \
5765                                   ZCL_GET_GROUP_IDENTIFIERS_REQUEST_COMMAND_ID, "uuuub", startIndex, total, startIndex, count,     \
5766                                   groupInformationRecordList, groupInformationRecordListLen);
5767
5768 /** @brief Command description for GetEndpointListRequest
5769  *
5770  * Command: GetEndpointListRequest
5771  * @param startIndex INT8U
5772  * @param total INT8U
5773  * @param startIndex INT8U
5774  * @param count INT8U
5775  * @param endpointInformationRecordList EndpointInformationRecord []
5776  * @param endpointInformationRecordListLen int
5777  */
5778 #define emberAfFillCommandZLL                                                                                                      \
5779     CommissioningClusterGetEndpointListRequest(startIndex, total, startIndex, count, endpointInformationRecordList,                \
5780                                                endpointInformationRecordListLen)                                                   \
5781         emberAfFillExternalBuffer(mask,                                                                                            \
5782                                                                                                                                    \
5783                                   ZCL_GET_ENDPOINT_LIST_REQUEST_COMMAND_ID, "uuuub", startIndex, total, startIndex, count,         \
5784                                   endpointInformationRecordList, endpointInformationRecordListLen);
5785
5786 /** @brief Command description for ScanNetworks
5787  *
5788  * Command: ScanNetworks
5789  * @param ssid OCTET_STRING
5790  * @param breadcrumb INT64U
5791  * @param timeoutMs INT32U
5792  */
5793 #define emberAfFillCommandNetwork                                                                                                  \
5794     CommissioningClusterScanNetworks(ssid, breadcrumb, timeoutMs)                                                                  \
5795         emberAfFillExternalBuffer(mask,                                                                                            \
5796                                                                                                                                    \
5797                                   ZCL_SCAN_NETWORKS_COMMAND_ID, "uuu", ssid, breadcrumb, timeoutMs);
5798
5799 /** @brief Command description for ScanNetworksResponse
5800  *
5801  * Command: ScanNetworksResponse
5802  * @param errorCode INT8U
5803  * @param debugText CHAR_STRING
5804  * @param wifiScanResults WiFiInterfaceScanResult []
5805  * @param wifiScanResultsLen int
5806  * @param threadScanResults ThreadInterfaceScanResult []
5807  * @param threadScanResultsLen int
5808  */
5809 #define emberAfFillCommandNetwork                                                                                                  \
5810     CommissioningClusterScanNetworksResponse(errorCode, debugText, wifiScanResults, wifiScanResultsLen, threadScanResults,         \
5811                                              threadScanResultsLen)                                                                 \
5812         emberAfFillExternalBuffer(mask,                                                                                            \
5813                                                                                                                                    \
5814                                   ZCL_SCAN_NETWORKS_RESPONSE_COMMAND_ID, "uubb", errorCode, debugText, wifiScanResults,            \
5815                                   wifiScanResultsLen, threadScanResults, threadScanResultsLen);
5816
5817 /** @brief Command description for AddWiFiNetwork
5818  *
5819  * Command: AddWiFiNetwork
5820  * @param ssid OCTET_STRING
5821  * @param credentials OCTET_STRING
5822  * @param breadcrumb INT64U
5823  * @param timeoutMs INT32U
5824  */
5825 #define emberAfFillCommandNetwork                                                                                                  \
5826     CommissioningClusterAddWiFiNetwork(ssid, credentials, breadcrumb, timeoutMs)                                                   \
5827         emberAfFillExternalBuffer(mask,                                                                                            \
5828                                                                                                                                    \
5829                                   ZCL_ADD_WI_FI_NETWORK_COMMAND_ID, "uuuu", ssid, credentials, breadcrumb, timeoutMs);
5830
5831 /** @brief Command description for AddWiFiNetworkResponse
5832  *
5833  * Command: AddWiFiNetworkResponse
5834  * @param errorCode INT8U
5835  * @param debugText CHAR_STRING
5836  */
5837 #define emberAfFillCommandNetwork                                                                                                  \
5838     CommissioningClusterAddWiFiNetworkResponse(errorCode, debugText)                                                               \
5839         emberAfFillExternalBuffer(mask,                                                                                            \
5840                                                                                                                                    \
5841                                   ZCL_ADD_WI_FI_NETWORK_RESPONSE_COMMAND_ID, "uu", errorCode, debugText);
5842
5843 /** @brief Command description for UpdateWiFiNetwork
5844  *
5845  * Command: UpdateWiFiNetwork
5846  * @param ssid OCTET_STRING
5847  * @param credentials OCTET_STRING
5848  * @param breadcrumb INT64U
5849  * @param timeoutMs INT32U
5850  */
5851 #define emberAfFillCommandNetwork                                                                                                  \
5852     CommissioningClusterUpdateWiFiNetwork(ssid, credentials, breadcrumb, timeoutMs)                                                \
5853         emberAfFillExternalBuffer(mask,                                                                                            \
5854                                                                                                                                    \
5855                                   ZCL_UPDATE_WI_FI_NETWORK_COMMAND_ID, "uuuu", ssid, credentials, breadcrumb, timeoutMs);
5856
5857 /** @brief Command description for UpdateWiFiNetworkResponse
5858  *
5859  * Command: UpdateWiFiNetworkResponse
5860  * @param errorCode INT8U
5861  * @param debugText CHAR_STRING
5862  */
5863 #define emberAfFillCommandNetwork                                                                                                  \
5864     CommissioningClusterUpdateWiFiNetworkResponse(errorCode, debugText)                                                            \
5865         emberAfFillExternalBuffer(mask,                                                                                            \
5866                                                                                                                                    \
5867                                   ZCL_UPDATE_WI_FI_NETWORK_RESPONSE_COMMAND_ID, "uu", errorCode, debugText);
5868
5869 /** @brief Command description for AddThreadNetwork
5870  *
5871  * Command: AddThreadNetwork
5872  * @param operationalDataset OCTET_STRING
5873  * @param breadcrumb INT64U
5874  * @param timeoutMs INT32U
5875  */
5876 #define emberAfFillCommandNetwork                                                                                                  \
5877     CommissioningClusterAddThreadNetwork(operationalDataset, breadcrumb, timeoutMs)                                                \
5878         emberAfFillExternalBuffer(mask,                                                                                            \
5879                                                                                                                                    \
5880                                   ZCL_ADD_THREAD_NETWORK_COMMAND_ID, "uuu", operationalDataset, breadcrumb, timeoutMs);
5881
5882 /** @brief Command description for AddThreadNetworkResponse
5883  *
5884  * Command: AddThreadNetworkResponse
5885  * @param errorCode INT8U
5886  * @param debugText CHAR_STRING
5887  */
5888 #define emberAfFillCommandNetwork                                                                                                  \
5889     CommissioningClusterAddThreadNetworkResponse(errorCode, debugText)                                                             \
5890         emberAfFillExternalBuffer(mask,                                                                                            \
5891                                                                                                                                    \
5892                                   ZCL_ADD_THREAD_NETWORK_RESPONSE_COMMAND_ID, "uu", errorCode, debugText);
5893
5894 /** @brief Command description for UpdateThreadNetwork
5895  *
5896  * Command: UpdateThreadNetwork
5897  * @param operationalDataset OCTET_STRING
5898  * @param breadcrumb INT64U
5899  * @param timeoutMs INT32U
5900  */
5901 #define emberAfFillCommandNetwork                                                                                                  \
5902     CommissioningClusterUpdateThreadNetwork(operationalDataset, breadcrumb, timeoutMs)                                             \
5903         emberAfFillExternalBuffer(mask,                                                                                            \
5904                                                                                                                                    \
5905                                   ZCL_UPDATE_THREAD_NETWORK_COMMAND_ID, "uuu", operationalDataset, breadcrumb, timeoutMs);
5906
5907 /** @brief Command description for UpdateThreadNetworkResponse
5908  *
5909  * Command: UpdateThreadNetworkResponse
5910  * @param errorCode INT8U
5911  * @param debugText CHAR_STRING
5912  */
5913 #define emberAfFillCommandNetwork                                                                                                  \
5914     CommissioningClusterUpdateThreadNetworkResponse(errorCode, debugText)                                                          \
5915         emberAfFillExternalBuffer(mask,                                                                                            \
5916                                                                                                                                    \
5917                                   ZCL_UPDATE_THREAD_NETWORK_RESPONSE_COMMAND_ID, "uu", errorCode, debugText);
5918
5919 /** @brief Command description for RemoveNetwork
5920  *
5921  * Command: RemoveNetwork
5922  * @param NetworkID OCTET_STRING
5923  * @param Breadcrumb INT64U
5924  * @param TimeoutMs INT32U
5925  */
5926 #define emberAfFillCommandNetwork                                                                                                  \
5927     CommissioningClusterRemoveNetwork(NetworkID, Breadcrumb, TimeoutMs)                                                            \
5928         emberAfFillExternalBuffer(mask,                                                                                            \
5929                                                                                                                                    \
5930                                   ZCL_REMOVE_NETWORK_COMMAND_ID, "uuu", NetworkID, Breadcrumb, TimeoutMs);
5931
5932 /** @brief Command description for RemoveNetworkResponse
5933  *
5934  * Command: RemoveNetworkResponse
5935  * @param errorCode INT8U
5936  * @param debugText CHAR_STRING
5937  */
5938 #define emberAfFillCommandNetwork                                                                                                  \
5939     CommissioningClusterRemoveNetworkResponse(errorCode, debugText)                                                                \
5940         emberAfFillExternalBuffer(mask,                                                                                            \
5941                                                                                                                                    \
5942                                   ZCL_REMOVE_NETWORK_RESPONSE_COMMAND_ID, "uu", errorCode, debugText);
5943
5944 /** @brief Command description for EnableNetwork
5945  *
5946  * Command: EnableNetwork
5947  * @param networkID OCTET_STRING
5948  * @param breadcrumb INT64U
5949  * @param timeoutMs INT32U
5950  */
5951 #define emberAfFillCommandNetwork                                                                                                  \
5952     CommissioningClusterEnableNetwork(networkID, breadcrumb, timeoutMs)                                                            \
5953         emberAfFillExternalBuffer(mask,                                                                                            \
5954                                                                                                                                    \
5955                                   ZCL_ENABLE_NETWORK_COMMAND_ID, "uuu", networkID, breadcrumb, timeoutMs);
5956
5957 /** @brief Command description for EnableNetworkResponse
5958  *
5959  * Command: EnableNetworkResponse
5960  * @param errorCode INT8U
5961  * @param debugText CHAR_STRING
5962  */
5963 #define emberAfFillCommandNetwork                                                                                                  \
5964     CommissioningClusterEnableNetworkResponse(errorCode, debugText)                                                                \
5965         emberAfFillExternalBuffer(mask,                                                                                            \
5966                                                                                                                                    \
5967                                   ZCL_ENABLE_NETWORK_RESPONSE_COMMAND_ID, "uu", errorCode, debugText);
5968
5969 /** @brief Command description for DisableNetwork
5970  *
5971  * Command: DisableNetwork
5972  * @param networkID OCTET_STRING
5973  * @param breadcrumb INT64U
5974  * @param timeoutMs INT32U
5975  */
5976 #define emberAfFillCommandNetwork                                                                                                  \
5977     CommissioningClusterDisableNetwork(networkID, breadcrumb, timeoutMs)                                                           \
5978         emberAfFillExternalBuffer(mask,                                                                                            \
5979                                                                                                                                    \
5980                                   ZCL_DISABLE_NETWORK_COMMAND_ID, "uuu", networkID, breadcrumb, timeoutMs);
5981
5982 /** @brief Command description for DisableNetworkResponse
5983  *
5984  * Command: DisableNetworkResponse
5985  * @param errorCode INT8U
5986  * @param debugText CHAR_STRING
5987  */
5988 #define emberAfFillCommandNetwork                                                                                                  \
5989     CommissioningClusterDisableNetworkResponse(errorCode, debugText)                                                               \
5990         emberAfFillExternalBuffer(mask,                                                                                            \
5991                                                                                                                                    \
5992                                   ZCL_DISABLE_NETWORK_RESPONSE_COMMAND_ID, "uu", errorCode, debugText);
5993
5994 /** @brief Command description for GetLastNetworkCommissioningResult
5995  *
5996  * Command: GetLastNetworkCommissioningResult
5997  * @param timeoutMs INT32U
5998  */
5999 #define emberAfFillCommandNetwork                                                                                                  \
6000     CommissioningClusterGetLastNetworkCommissioningResult(timeoutMs)                                                               \
6001         emberAfFillExternalBuffer(mask,                                                                                            \
6002                                                                                                                                    \
6003                                   ZCL_GET_LAST_NETWORK_COMMISSIONING_RESULT_COMMAND_ID, "u", timeoutMs);
6004
6005 /** @brief Command description for Bind
6006  *
6007  * Command: Bind
6008  * @param nodeId NODE_ID
6009  * @param groupId GROUP_ID
6010  * @param endpointId ENDPOINT_ID
6011  * @param clusterId CLUSTER_ID
6012  */
6013 #define emberAfFillCommandBindingClusterBind(nodeId, groupId, endpointId, clusterId)                                               \
6014     emberAfFillExternalBuffer(mask,                                                                                                \
6015                                                                                                                                    \
6016                               ZCL_BIND_COMMAND_ID, "uuuu", nodeId, groupId, endpointId, clusterId);
6017
6018 /** @brief Command description for Unbind
6019  *
6020  * Command: Unbind
6021  * @param nodeId NODE_ID
6022  * @param groupId GROUP_ID
6023  * @param endpointId ENDPOINT_ID
6024  * @param clusterId CLUSTER_ID
6025  */
6026 #define emberAfFillCommandBindingClusterUnbind(nodeId, groupId, endpointId, clusterId)                                             \
6027     emberAfFillExternalBuffer(mask,                                                                                                \
6028                                                                                                                                    \
6029                               ZCL_UNBIND_COMMAND_ID, "uuuu", nodeId, groupId, endpointId, clusterId);
6030
6031 /** @brief Command description for PlayRequest
6032  *
6033  * Command: PlayRequest
6034  */
6035 #define emberAfFillCommandMedia                                                                                                    \
6036     PlaybackClusterPlayRequest() emberAfFillExternalBuffer(mask,                                                                   \
6037                                                                                                                                    \
6038                                                            ZCL_PLAY_REQUEST_COMMAND_ID, "", );
6039
6040 /** @brief Command description for PauseRequest
6041  *
6042  * Command: PauseRequest
6043  */
6044 #define emberAfFillCommandMedia                                                                                                    \
6045     PlaybackClusterPauseRequest() emberAfFillExternalBuffer(mask,                                                                  \
6046                                                                                                                                    \
6047                                                             ZCL_PAUSE_REQUEST_COMMAND_ID, "", );
6048
6049 /** @brief Command description for StopRequest
6050  *
6051  * Command: StopRequest
6052  */
6053 #define emberAfFillCommandMedia                                                                                                    \
6054     PlaybackClusterStopRequest() emberAfFillExternalBuffer(mask,                                                                   \
6055                                                                                                                                    \
6056                                                            ZCL_STOP_REQUEST_COMMAND_ID, "", );
6057
6058 /** @brief Command description for StartOverRequest
6059  *
6060  * Command: StartOverRequest
6061  */
6062 #define emberAfFillCommandMedia                                                                                                    \
6063     PlaybackClusterStartOverRequest() emberAfFillExternalBuffer(mask,                                                              \
6064                                                                                                                                    \
6065                                                                 ZCL_START_OVER_REQUEST_COMMAND_ID, "", );
6066
6067 /** @brief Command description for PreviousRequest
6068  *
6069  * Command: PreviousRequest
6070  */
6071 #define emberAfFillCommandMedia                                                                                                    \
6072     PlaybackClusterPreviousRequest() emberAfFillExternalBuffer(mask,                                                               \
6073                                                                                                                                    \
6074                                                                ZCL_PREVIOUS_REQUEST_COMMAND_ID, "", );
6075
6076 /** @brief Command description for NextRequest
6077  *
6078  * Command: NextRequest
6079  */
6080 #define emberAfFillCommandMedia                                                                                                    \
6081     PlaybackClusterNextRequest() emberAfFillExternalBuffer(mask,                                                                   \
6082                                                                                                                                    \
6083                                                            ZCL_NEXT_REQUEST_COMMAND_ID, "", );
6084
6085 /** @brief Command description for RewindRequest
6086  *
6087  * Command: RewindRequest
6088  */
6089 #define emberAfFillCommandMedia                                                                                                    \
6090     PlaybackClusterRewindRequest() emberAfFillExternalBuffer(mask,                                                                 \
6091                                                                                                                                    \
6092                                                              ZCL_REWIND_REQUEST_COMMAND_ID, "", );
6093
6094 /** @brief Command description for FastForwardRequest
6095  *
6096  * Command: FastForwardRequest
6097  */
6098 #define emberAfFillCommandMedia                                                                                                    \
6099     PlaybackClusterFastForwardRequest() emberAfFillExternalBuffer(mask,                                                            \
6100                                                                                                                                    \
6101                                                                   ZCL_FAST_FORWARD_REQUEST_COMMAND_ID, "", );
6102
6103 /** @brief Command description for SkipForwardRequest
6104  *
6105  * Command: SkipForwardRequest
6106  */
6107 #define emberAfFillCommandMedia                                                                                                    \
6108     PlaybackClusterSkipForwardRequest() emberAfFillExternalBuffer(mask,                                                            \
6109                                                                                                                                    \
6110                                                                   ZCL_SKIP_FORWARD_REQUEST_COMMAND_ID, "", );
6111
6112 /** @brief Command description for SkipBackwardRequest
6113  *
6114  * Command: SkipBackwardRequest
6115  */
6116 #define emberAfFillCommandMedia                                                                                                    \
6117     PlaybackClusterSkipBackwardRequest() emberAfFillExternalBuffer(mask,                                                           \
6118                                                                                                                                    \
6119                                                                    ZCL_SKIP_BACKWARD_REQUEST_COMMAND_ID, "", );
6120
6121 /** @brief Command description for LaunchContent
6122  *
6123  * Command: LaunchContent
6124  * @param contentLaunchStatus ContentLaunchStatus
6125  */
6126 #define emberAfFillCommandContent                                                                                                  \
6127     LaunchClusterLaunchContent(contentLaunchStatus)                                                                                \
6128         emberAfFillExternalBuffer(mask,                                                                                            \
6129                                                                                                                                    \
6130                                   ZCL_LAUNCH_CONTENT_COMMAND_ID, "u", contentLaunchStatus);
6131
6132 /** @brief Command description for LaunchURL
6133  *
6134  * Command: LaunchURL
6135  * @param contentLaunchStatus ContentLaunchStatus
6136  */
6137 #define emberAfFillCommandContent                                                                                                  \
6138     LaunchClusterLaunchURL(contentLaunchStatus) emberAfFillExternalBuffer(mask,                                                    \
6139                                                                                                                                    \
6140                                                                           ZCL_LAUNCH_URL_COMMAND_ID, "u", contentLaunchStatus);
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);