examples/chip-tool/gen/client-command-macro.h

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