examples/lock-app/lock-common/gen/client-command-macro.h

   1 /*
   2  *
   3  *    Copyright (c) 2021 Project CHIP Authors
   4  *
   5  *    Licensed under the Apache License, Version 2.0 (the "License");
   6  *    you may not use this file except in compliance with the License.
   7  *    You may obtain a copy of the License at
   8  *
   9  *        http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *    Unless required by applicable law or agreed to in writing, software
  12  *    distributed under the License is distributed on an "AS IS" BASIS,
  13  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *    See the License for the specific language governing permissions and
  15  *    limitations under the License.
  16  */
  17
  18 // THIS FILE IS GENERATED BY ZAP
  19
  20 // Prevent multiple inclusion
  21 #pragma once
  22
  23 /** @brief Command description for ReadAttributes
  24  *
  25  * Command: ReadAttributes
  26  * @param attributeIds ATTRIBUTE_ID []
  27  * @param attributeIdsLen int
  28  */
  29 #define emberAfFillCommandGlobalReadAttributes(clusterId, attributeIds, attributeIdsLen)                                           \
  30     emberAfFillExternalBuffer(mask, clusterId, ZCL_READ_ATTRIBUTES_COMMAND_ID, "b", attributeIds, attributeIdsLen);
  31
  32 /** @brief Command description for ReadAttributesResponse
  33  *
  34  * Command: ReadAttributesResponse
  35  * @param readAttributeStatusRecords ReadAttributeStatusRecord []
  36  * @param readAttributeStatusRecordsLen int
  37  */
  38 #define emberAfFillCommandGlobalReadAttributesResponse(clusterId, readAttributeStatusRecords, readAttributeStatusRecordsLen)       \
  39     emberAfFillExternalBuffer(mask, clusterId, ZCL_READ_ATTRIBUTES_RESPONSE_COMMAND_ID, "b", readAttributeStatusRecords,           \
  40                               readAttributeStatusRecordsLen);
  41
  42 /** @brief Command description for WriteAttributes
  43  *
  44  * Command: WriteAttributes
  45  * @param writeAttributeRecords WriteAttributeRecord []
  46  * @param writeAttributeRecordsLen int
  47  */
  48 #define emberAfFillCommandGlobalWriteAttributes(clusterId, writeAttributeRecords, writeAttributeRecordsLen)                        \
  49     emberAfFillExternalBuffer(mask, clusterId, ZCL_WRITE_ATTRIBUTES_COMMAND_ID, "b", writeAttributeRecords,                        \
  50                               writeAttributeRecordsLen);
  51
  52 /** @brief Command description for WriteAttributesUndivided
  53  *
  54  * Command: WriteAttributesUndivided
  55  * @param writeAttributeRecords WriteAttributeRecord []
  56  * @param writeAttributeRecordsLen int
  57  */
  58 #define emberAfFillCommandGlobalWriteAttributesUndivided(clusterId, writeAttributeRecords, writeAttributeRecordsLen)               \
  59     emberAfFillExternalBuffer(mask, clusterId, ZCL_WRITE_ATTRIBUTES_UNDIVIDED_COMMAND_ID, "b", writeAttributeRecords,              \
  60                               writeAttributeRecordsLen);
  61
  62 /** @brief Command description for WriteAttributesResponse
  63  *
  64  * Command: WriteAttributesResponse
  65  * @param writeAttributeStatusRecords WriteAttributeStatusRecord []
  66  * @param writeAttributeStatusRecordsLen int
  67  */
  68 #define emberAfFillCommandGlobalWriteAttributesResponse(clusterId, writeAttributeStatusRecords, writeAttributeStatusRecordsLen)    \
  69     emberAfFillExternalBuffer(mask, clusterId, ZCL_WRITE_ATTRIBUTES_RESPONSE_COMMAND_ID, "b", writeAttributeStatusRecords,         \
  70                               writeAttributeStatusRecordsLen);
  71
  72 /** @brief Command description for WriteAttributesNoResponse
  73  *
  74  * Command: WriteAttributesNoResponse
  75  * @param writeAttributeRecords WriteAttributeRecord []
  76  * @param writeAttributeRecordsLen int
  77  */
  78 #define emberAfFillCommandGlobalWriteAttributesNoResponse(clusterId, writeAttributeRecords, writeAttributeRecordsLen)              \
  79     emberAfFillExternalBuffer(mask, clusterId, ZCL_WRITE_ATTRIBUTES_NO_RESPONSE_COMMAND_ID, "b", writeAttributeRecords,            \
  80                               writeAttributeRecordsLen);
  81
  82 /** @brief Command description for ConfigureReporting
  83  *
  84  * Command: ConfigureReporting
  85  * @param configureReportingRecords ConfigureReportingRecord []
  86  * @param configureReportingRecordsLen int
  87  */
  88 #define emberAfFillCommandGlobalConfigureReporting(clusterId, configureReportingRecords, configureReportingRecordsLen)             \
  89     emberAfFillExternalBuffer(mask, clusterId, ZCL_CONFIGURE_REPORTING_COMMAND_ID, "b", configureReportingRecords,                 \
  90                               configureReportingRecordsLen);
  91
  92 /** @brief Command description for ConfigureReportingResponse
  93  *
  94  * Command: ConfigureReportingResponse
  95  * @param configureReportingStatusRecords ConfigureReportingStatusRecord []
  96  * @param configureReportingStatusRecordsLen int
  97  */
  98 #define emberAfFillCommandGlobalConfigureReportingResponse(clusterId, configureReportingStatusRecords,                             \
  99                                                            configureReportingStatusRecordsLen)                                     \
 100     emberAfFillExternalBuffer(mask, clusterId, ZCL_CONFIGURE_REPORTING_RESPONSE_COMMAND_ID, "b", configureReportingStatusRecords,  \
 101                               configureReportingStatusRecordsLen);
 102
 103 /** @brief Command description for ReadReportingConfiguration
 104  *
 105  * Command: ReadReportingConfiguration
 106  * @param readReportingConfigurationAttributeRecords ReadReportingConfigurationAttributeRecord []
 107  * @param readReportingConfigurationAttributeRecordsLen int
 108  */
 109 #define emberAfFillCommandGlobalReadReportingConfiguration(clusterId, readReportingConfigurationAttributeRecords,                  \
 110                                                            readReportingConfigurationAttributeRecordsLen)                          \
 111     emberAfFillExternalBuffer(mask, clusterId, ZCL_READ_REPORTING_CONFIGURATION_COMMAND_ID, "b",                                   \
 112                               readReportingConfigurationAttributeRecords, readReportingConfigurationAttributeRecordsLen);
 113
 114 /** @brief Command description for ReadReportingConfigurationResponse
 115  *
 116  * Command: ReadReportingConfigurationResponse
 117  * @param readReportingConfigurationRecords ReadReportingConfigurationRecord []
 118  * @param readReportingConfigurationRecordsLen int
 119  */
 120 #define emberAfFillCommandGlobalReadReportingConfigurationResponse(clusterId, readReportingConfigurationRecords,                   \
 121                                                                    readReportingConfigurationRecordsLen)                           \
 122     emberAfFillExternalBuffer(mask, clusterId, ZCL_READ_REPORTING_CONFIGURATION_RESPONSE_COMMAND_ID, "b",                          \
 123                               readReportingConfigurationRecords, readReportingConfigurationRecordsLen);
 124
 125 /** @brief Command description for ReportAttributes
 126  *
 127  * Command: ReportAttributes
 128  * @param reportAttributeRecords ReportAttributeRecord []
 129  * @param reportAttributeRecordsLen int
 130  */
 131 #define emberAfFillCommandGlobalReportAttributes(clusterId, reportAttributeRecords, reportAttributeRecordsLen)                     \
 132     emberAfFillExternalBuffer(mask, clusterId, ZCL_REPORT_ATTRIBUTES_COMMAND_ID, "b", reportAttributeRecords,                      \
 133                               reportAttributeRecordsLen);
 134
 135 /** @brief Command description for DefaultResponse
 136  *
 137  * Command: DefaultResponse
 138  * @param commandId INT8U
 139  * @param status Status
 140  */
 141 #define emberAfFillCommandGlobalDefaultResponse(clusterId, commandId, status)                                                      \
 142     emberAfFillExternalBuffer(mask, clusterId, ZCL_DEFAULT_RESPONSE_COMMAND_ID, "uu", commandId, status);
 143
 144 /** @brief Command description for DiscoverAttributes
 145  *
 146  * Command: DiscoverAttributes
 147  * @param startId ATTRIBUTE_ID
 148  * @param maxAttributeIds INT8U
 149  */
 150 #define emberAfFillCommandGlobalDiscoverAttributes(clusterId, startId, maxAttributeIds)                                            \
 151     emberAfFillExternalBuffer(mask, clusterId, ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID, "uu", startId, maxAttributeIds);
 152
 153 /** @brief Command description for DiscoverAttributesResponse
 154  *
 155  * Command: DiscoverAttributesResponse
 156  * @param discoveryComplete INT8U
 157  * @param discoverAttributesInfoRecords DiscoverAttributesInfoRecord []
 158  * @param discoverAttributesInfoRecordsLen int
 159  */
 160 #define emberAfFillCommandGlobalDiscoverAttributesResponse(clusterId, discoveryComplete, discoverAttributesInfoRecords,            \
 161                                                            discoverAttributesInfoRecordsLen)                                       \
 162     emberAfFillExternalBuffer(mask, clusterId, ZCL_DISCOVER_ATTRIBUTES_RESPONSE_COMMAND_ID, "ub", discoveryComplete,               \
 163                               discoverAttributesInfoRecords, discoverAttributesInfoRecordsLen);
 164
 165 /** @brief Command description for ReadAttributesStructured
 166  *
 167  * Command: ReadAttributesStructured
 168  * @param readStructuredAttributeRecords ReadStructuredAttributeRecord []
 169  * @param readStructuredAttributeRecordsLen int
 170  */
 171 #define emberAfFillCommandGlobalReadAttributesStructured(clusterId, readStructuredAttributeRecords,                                \
 172                                                          readStructuredAttributeRecordsLen)                                        \
 173     emberAfFillExternalBuffer(mask, clusterId, ZCL_READ_ATTRIBUTES_STRUCTURED_COMMAND_ID, "b", readStructuredAttributeRecords,     \
 174                               readStructuredAttributeRecordsLen);
 175
 176 /** @brief Command description for WriteAttributesStructured
 177  *
 178  * Command: WriteAttributesStructured
 179  * @param writeStructuredAttributeRecords WriteStructuredAttributeRecord []
 180  * @param writeStructuredAttributeRecordsLen int
 181  */
 182 #define emberAfFillCommandGlobalWriteAttributesStructured(clusterId, writeStructuredAttributeRecords,                              \
 183                                                           writeStructuredAttributeRecordsLen)                                      \
 184     emberAfFillExternalBuffer(mask, clusterId, ZCL_WRITE_ATTRIBUTES_STRUCTURED_COMMAND_ID, "b", writeStructuredAttributeRecords,   \
 185                               writeStructuredAttributeRecordsLen);
 186
 187 /** @brief Command description for WriteAttributesStructuredResponse
 188  *
 189  * Command: WriteAttributesStructuredResponse
 190  * @param writeStructuredAttributeStatusRecords WriteStructuredAttributeStatusRecord []
 191  * @param writeStructuredAttributeStatusRecordsLen int
 192  */
 193 #define emberAfFillCommandGlobalWriteAttributesStructuredResponse(clusterId, writeStructuredAttributeStatusRecords,                \
 194                                                                   writeStructuredAttributeStatusRecordsLen)                        \
 195     emberAfFillExternalBuffer(mask, clusterId, ZCL_WRITE_ATTRIBUTES_STRUCTURED_RESPONSE_COMMAND_ID, "b",                           \
 196                               writeStructuredAttributeStatusRecords, writeStructuredAttributeStatusRecordsLen);
 197
 198 /** @brief Command description for DiscoverCommandsReceived
 199  *
 200  * Command: DiscoverCommandsReceived
 201  * @param startCommandId INT8U
 202  * @param maxCommandIds INT8U
 203  */
 204 #define emberAfFillCommandGlobalDiscoverCommandsReceived(clusterId, startCommandId, maxCommandIds)                                 \
 205     emberAfFillExternalBuffer(mask, clusterId, ZCL_DISCOVER_COMMANDS_RECEIVED_COMMAND_ID, "uu", startCommandId, maxCommandIds);
 206
 207 /** @brief Command description for DiscoverCommandsReceivedResponse
 208  *
 209  * Command: DiscoverCommandsReceivedResponse
 210  * @param discoveryComplete INT8U
 211  * @param commandIds INT8U []
 212  * @param commandIdsLen int
 213  */
 214 #define emberAfFillCommandGlobalDiscoverCommandsReceivedResponse(clusterId, discoveryComplete, commandIds, commandIdsLen)          \
 215     emberAfFillExternalBuffer(mask, clusterId, ZCL_DISCOVER_COMMANDS_RECEIVED_RESPONSE_COMMAND_ID, "ub", discoveryComplete,        \
 216                               commandIds, commandIdsLen);
 217
 218 /** @brief Command description for DiscoverCommandsGenerated
 219  *
 220  * Command: DiscoverCommandsGenerated
 221  * @param startCommandId INT8U
 222  * @param maxCommandIds INT8U
 223  */
 224 #define emberAfFillCommandGlobalDiscoverCommandsGenerated(clusterId, startCommandId, maxCommandIds)                                \
 225     emberAfFillExternalBuffer(mask, clusterId, ZCL_DISCOVER_COMMANDS_GENERATED_COMMAND_ID, "uu", startCommandId, maxCommandIds);
 226
 227 /** @brief Command description for DiscoverCommandsGeneratedResponse
 228  *
 229  * Command: DiscoverCommandsGeneratedResponse
 230  * @param discoveryComplete INT8U
 231  * @param commandIds INT8U []
 232  * @param commandIdsLen int
 233  */
 234 #define emberAfFillCommandGlobalDiscoverCommandsGeneratedResponse(clusterId, discoveryComplete, commandIds, commandIdsLen)         \
 235     emberAfFillExternalBuffer(mask, clusterId, ZCL_DISCOVER_COMMANDS_GENERATED_RESPONSE_COMMAND_ID, "ub", discoveryComplete,       \
 236                               commandIds, commandIdsLen);
 237
 238 /** @brief Command description for DiscoverAttributesExtended
 239  *
 240  * Command: DiscoverAttributesExtended
 241  * @param startId ATTRIBUTE_ID
 242  * @param maxAttributeIds INT8U
 243  */
 244 #define emberAfFillCommandGlobalDiscoverAttributesExtended(clusterId, startId, maxAttributeIds)                                    \
 245     emberAfFillExternalBuffer(mask, clusterId, ZCL_DISCOVER_ATTRIBUTES_EXTENDED_COMMAND_ID, "uu", startId, maxAttributeIds);
 246
 247 /** @brief Command description for DiscoverAttributesExtendedResponse
 248  *
 249  * Command: DiscoverAttributesExtendedResponse
 250  * @param discoveryComplete INT8U
 251  * @param extendedDiscoverAttributesInfoRecords ExtendedDiscoverAttributesInfoRecord []
 252  * @param extendedDiscoverAttributesInfoRecordsLen int
 253  */
 254 #define emberAfFillCommandGlobalDiscoverAttributesExtendedResponse(                                                                \
 255     clusterId, discoveryComplete, extendedDiscoverAttributesInfoRecords, extendedDiscoverAttributesInfoRecordsLen)                 \
 256     emberAfFillExternalBuffer(mask, clusterId, ZCL_DISCOVER_ATTRIBUTES_EXTENDED_RESPONSE_COMMAND_ID, "ub", discoveryComplete,      \
 257                               extendedDiscoverAttributesInfoRecords, extendedDiscoverAttributesInfoRecordsLen);
 258
 259 /** @brief Command description for 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 MatchProtocolAddress
2968  *
2969  * Command: MatchProtocolAddress
2970  * @param protocolAddress OCTET_STRING
2971  * @param deviceIeeeAddress IEEE_ADDRESS
2972  * @param protocolAddress OCTET_STRING
2973  */
2974 #define emberAfFillCommandGeneric                                                                                                  \
2975     TunnelClusterMatchProtocolAddress(protocolAddress, deviceIeeeAddress, protocolAddress) emberAfFillExternalBuffer(              \
2976         mask,                                                                                                                      \
2977                                                                                                                                    \
2978         ZCL_MATCH_PROTOCOL_ADDRESS_COMMAND_ID, "uuu", protocolAddress, deviceIeeeAddress, protocolAddress);
2979
2980 /** @brief Command description for AdvertiseProtocolAddress
2981  *
2982  * Command: AdvertiseProtocolAddress
2983  * @param protocolAddress OCTET_STRING
2984  */
2985 #define emberAfFillCommandGeneric                                                                                                  \
2986     TunnelClusterAdvertiseProtocolAddress(protocolAddress)                                                                         \
2987         emberAfFillExternalBuffer(mask,                                                                                            \
2988                                                                                                                                    \
2989                                   ZCL_ADVERTISE_PROTOCOL_ADDRESS_COMMAND_ID, "u", protocolAddress);
2990
2991 /** @brief Command description for TransferNpdu
2992  *
2993  * Command: TransferNpdu
2994  * @param npdu DATA8 []
2995  * @param npduLen int
2996  */
2997 #define emberAfFillCommandBACnet                                                                                                   \
2998     Protocol TunnelClusterTransferNpdu(npdu, npduLen) emberAfFillExternalBuffer(mask,                                              \
2999                                                                                                                                    \
3000                                                                                 ZCL_TRANSFER_NPDU_COMMAND_ID, "b", npdu, npduLen);
3001
3002 /** @brief Command description for TransferAPDU
3003  *
3004  * Command: TransferAPDU
3005  * @param apdu OCTET_STRING
3006  */
3007 #define emberAfFillCommand11073                                                                                                    \
3008     Protocol TunnelClusterTransferAPDU(apdu) emberAfFillExternalBuffer(mask,                                                       \
3009                                                                                                                                    \
3010                                                                        ZCL_TRANSFER_APDU_COMMAND_ID, "u", apdu);
3011
3012 /** @brief Command description for ConnectRequest
3013  *
3014  * Command: ConnectRequest
3015  * @param connectControl 11073ConnectRequestConnectControl
3016  * @param idleTimeout INT16U
3017  * @param managerTarget IEEE_ADDRESS
3018  * @param managerEndpoint INT8U
3019  */
3020 #define emberAfFillCommand11073                                                                                                    \
3021     Protocol TunnelClusterConnectRequest(connectControl, idleTimeout, managerTarget, managerEndpoint) emberAfFillExternalBuffer(   \
3022         mask,                                                                                                                      \
3023                                                                                                                                    \
3024         ZCL_CONNECT_REQUEST_COMMAND_ID, "uuuu", connectControl, idleTimeout, managerTarget, managerEndpoint);
3025
3026 /** @brief Command description for DisconnectRequest
3027  *
3028  * Command: DisconnectRequest
3029  * @param managerIEEEAddress IEEE_ADDRESS
3030  */
3031 #define emberAfFillCommand11073                                                                                                    \
3032     Protocol TunnelClusterDisconnectRequest(managerIEEEAddress)                                                                    \
3033         emberAfFillExternalBuffer(mask,                                                                                            \
3034                                                                                                                                    \
3035                                   ZCL_DISCONNECT_REQUEST_COMMAND_ID, "u", managerIEEEAddress);
3036
3037 /** @brief Command description for ConnectStatusNotification
3038  *
3039  * Command: ConnectStatusNotification
3040  * @param connectStatus 11073TunnelConnectionStatus
3041  */
3042 #define emberAfFillCommand11073                                                                                                    \
3043     Protocol TunnelClusterConnectStatusNotification(connectStatus)                                                                 \
3044         emberAfFillExternalBuffer(mask,                                                                                            \
3045                                                                                                                                    \
3046                                   ZCL_CONNECT_STATUS_NOTIFICATION_COMMAND_ID, "u", connectStatus);
3047
3048 /** @brief Command description for TransferApdu
3049  *
3050  * Command: TransferApdu
3051  * @param apdu OCTET_STRING
3052  */
3053 #define emberAfFillCommandISO                                                                                                      \
3054     7816 Protocol TunnelClusterTransferApdu(apdu) emberAfFillExternalBuffer(mask,                                                  \
3055                                                                                                                                    \
3056                                                                             ZCL_TRANSFER_APDU_COMMAND_ID, "u", apdu);
3057
3058 /** @brief Command description for InsertSmartCard
3059  *
3060  * Command: InsertSmartCard
3061  */
3062 #define emberAfFillCommandISO                                                                                                      \
3063     7816 Protocol TunnelClusterInsertSmartCard() emberAfFillExternalBuffer(mask,                                                   \
3064                                                                                                                                    \
3065                                                                            ZCL_INSERT_SMART_CARD_COMMAND_ID, "", );
3066
3067 /** @brief Command description for ExtractSmartCard
3068  *
3069  * Command: ExtractSmartCard
3070  */
3071 #define emberAfFillCommandISO                                                                                                      \
3072     7816 Protocol TunnelClusterExtractSmartCard() emberAfFillExternalBuffer(mask,                                                  \
3073                                                                                                                                    \
3074                                                                             ZCL_EXTRACT_SMART_CARD_COMMAND_ID, "", );
3075
3076 /** @brief Command description for PublishPrice
3077  *
3078  * Command: PublishPrice
3079  * @param providerId INT32U
3080  * @param commandOptions AmiCommandOptions
3081  * @param rateLabel OCTET_STRING
3082  * @param issuerEventId INT32U
3083  * @param currentTime UTC_TIME
3084  * @param unitOfMeasure AmiUnitOfMeasure
3085  * @param currency INT16U
3086  * @param priceTrailingDigitAndPriceTier PriceTrailingDigitAndPriceTier
3087  * @param numberOfPriceTiersAndRegisterTier PriceNumberOfPriceTiersAndRegisterTier
3088  * @param startTime UTC_TIME
3089  * @param durationInMinutes INT16U
3090  * @param price INT32U
3091  * @param priceRatio INT8U
3092  * @param generationPrice INT32U
3093  * @param generationPriceRatio INT8U
3094  * @param alternateCostDelivered INT32U
3095  * @param alternateCostUnit AlternateCostUnit
3096  * @param alternateCostTrailingDigit AlternateCostTrailingDigit
3097  * @param numberOfBlockThresholds INT8U
3098  * @param priceControl PriceControlMask
3099  * @param numberOfGenerationTiers INT8U
3100  * @param generationTier GenerationTier
3101  * @param extendedNumberOfPriceTiers ExtendedNumberOfPriceTiers
3102  * @param extendedPriceTier ExtendedPriceTier
3103  * @param extendedRegisterTier ExtendedRegisterTier
3104  */
3105 #define emberAfFillCommandPriceClusterPublishPrice(                                                                                \
3106     providerId, commandOptions, rateLabel, issuerEventId, currentTime, unitOfMeasure, currency, priceTrailingDigitAndPriceTier,    \
3107     numberOfPriceTiersAndRegisterTier, startTime, durationInMinutes, price, priceRatio, generationPrice, generationPriceRatio,     \
3108     alternateCostDelivered, alternateCostUnit, alternateCostTrailingDigit, numberOfBlockThresholds, priceControl,                  \
3109     numberOfGenerationTiers, generationTier, extendedNumberOfPriceTiers, extendedPriceTier, extendedRegisterTier)                  \
3110     emberAfFillExternalBuffer(mask,                                                                                                \
3111                                                                                                                                    \
3112                               ZCL_PUBLISH_PRICE_COMMAND_ID, "uuuuuuuuuuuuuuuuuuuuuuuuu", providerId, commandOptions, rateLabel,    \
3113                               issuerEventId, currentTime, unitOfMeasure, currency, priceTrailingDigitAndPriceTier,                 \
3114                               numberOfPriceTiersAndRegisterTier, startTime, durationInMinutes, price, priceRatio, generationPrice, \
3115                               generationPriceRatio, alternateCostDelivered, alternateCostUnit, alternateCostTrailingDigit,         \
3116                               numberOfBlockThresholds, priceControl, numberOfGenerationTiers, generationTier,                      \
3117                               extendedNumberOfPriceTiers, extendedPriceTier, extendedRegisterTier);
3118
3119 /** @brief Command description for PublishBlockPeriod
3120  *
3121  * Command: PublishBlockPeriod
3122  * @param providerId INT32U
3123  * @param startTime UTC_TIME
3124  * @param issuerEventId INT32U
3125  * @param numberOfEvents INT8U
3126  * @param blockPeriodStartTime UTC_TIME
3127  * @param blockPeriodDuration INT24U
3128  * @param blockPeriodControl BlockPeriodControl
3129  * @param blockPeriodDurationType BlockPeriodDurationType
3130  * @param tariffType TariffType
3131  * @param tariffResolutionPeriod TariffResolutionPeriod
3132  */
3133 #define emberAfFillCommandPriceClusterPublishBlockPeriod(providerId, startTime, issuerEventId, numberOfEvents,                     \
3134                                                          blockPeriodStartTime, blockPeriodDuration, blockPeriodControl,            \
3135                                                          blockPeriodDurationType, tariffType, tariffResolutionPeriod)              \
3136     emberAfFillExternalBuffer(mask,                                                                                                \
3137                                                                                                                                    \
3138                               ZCL_PUBLISH_BLOCK_PERIOD_COMMAND_ID, "uuuuuuuuuu", providerId, startTime, issuerEventId,             \
3139                               numberOfEvents, blockPeriodStartTime, blockPeriodDuration, blockPeriodControl,                       \
3140                               blockPeriodDurationType, tariffType, tariffResolutionPeriod);
3141
3142 /** @brief Command description for PublishConversionFactor
3143  *
3144  * Command: PublishConversionFactor
3145  * @param issuerEventId INT32U
3146  * @param providerId INT32U
3147  * @param startTime UTC_TIME
3148  * @param issuerEventId INT32U
3149  * @param conversionFactor INT32U
3150  * @param priceAckTime UTC_TIME
3151  * @param conversionFactorTrailingDigit ConversionFactorTrailingDigit
3152  * @param control PriceControlMask
3153  */
3154 #define emberAfFillCommandPriceClusterPublishConversionFactor(                                                                     \
3155     issuerEventId, providerId, startTime, issuerEventId, conversionFactor, priceAckTime, conversionFactorTrailingDigit, control)   \
3156     emberAfFillExternalBuffer(mask,                                                                                                \
3157                                                                                                                                    \
3158                               ZCL_PUBLISH_CONVERSION_FACTOR_COMMAND_ID, "uuuuuuuu", issuerEventId, providerId, startTime,          \
3159                               issuerEventId, conversionFactor, priceAckTime, conversionFactorTrailingDigit, control);
3160
3161 /** @brief Command description for PublishCalorificValue
3162  *
3163  * Command: PublishCalorificValue
3164  * @param issuerEventId INT32U
3165  * @param startTime UTC_TIME
3166  * @param startTime UTC_TIME
3167  * @param numberOfEvents INT8U
3168  * @param calorificValue INT32U
3169  * @param tariffType TariffType
3170  * @param calorificValueUnit CalorificValueUnit
3171  * @param calorificValueTrailingDigit CalorificValueTrailingDigit
3172  */
3173 #define emberAfFillCommandPriceClusterPublishCalorificValue(issuerEventId, startTime, startTime, numberOfEvents, calorificValue,   \
3174                                                             tariffType, calorificValueUnit, calorificValueTrailingDigit)           \
3175     emberAfFillExternalBuffer(mask,                                                                                                \
3176                                                                                                                                    \
3177                               ZCL_PUBLISH_CALORIFIC_VALUE_COMMAND_ID, "uuuuuuuu", issuerEventId, startTime, startTime,             \
3178                               numberOfEvents, calorificValue, tariffType, calorificValueUnit, calorificValueTrailingDigit);
3179
3180 /** @brief Command description for PublishTariffInformation
3181  *
3182  * Command: PublishTariffInformation
3183  * @param providerId INT32U
3184  * @param earliestStartTime UTC_TIME
3185  * @param issuerEventId INT32U
3186  * @param minIssuerEventId INT32U
3187  * @param issuerTariffId INT32U
3188  * @param numberOfCommands INT8U
3189  * @param startTime UTC_TIME
3190  * @param tariffTypeChargingScheme TariffTypeChargingScheme
3191  * @param tariffLabel OCTET_STRING
3192  * @param numberOfPriceTiersInUse INT8U
3193  * @param numberOfBlockThresholdsInUse INT8U
3194  * @param unitOfMeasure AmiUnitOfMeasure
3195  * @param currency INT16U
3196  * @param priceTrailingDigit PriceTrailingDigit
3197  * @param standingCharge INT32U
3198  * @param tierBlockMode TierBlockMode
3199  * @param blockThresholdMultiplier INT24U
3200  * @param blockThresholdDivisor INT24U
3201  */
3202 #define emberAfFillCommandPriceClusterPublishTariffInformation(                                                                    \
3203     providerId, earliestStartTime, issuerEventId, minIssuerEventId, issuerTariffId, numberOfCommands, startTime,                   \
3204     tariffTypeChargingScheme, tariffLabel, numberOfPriceTiersInUse, numberOfBlockThresholdsInUse, unitOfMeasure, currency,         \
3205     priceTrailingDigit, standingCharge, tierBlockMode, blockThresholdMultiplier, blockThresholdDivisor)                            \
3206     emberAfFillExternalBuffer(mask,                                                                                                \
3207                                                                                                                                    \
3208                               ZCL_PUBLISH_TARIFF_INFORMATION_COMMAND_ID, "uuuuuuuuuuuuuuuuuu", providerId, earliestStartTime,      \
3209                               issuerEventId, minIssuerEventId, issuerTariffId, numberOfCommands, startTime,                        \
3210                               tariffTypeChargingScheme, tariffLabel, numberOfPriceTiersInUse, numberOfBlockThresholdsInUse,        \
3211                               unitOfMeasure, currency, priceTrailingDigit, standingCharge, tierBlockMode,                          \
3212                               blockThresholdMultiplier, blockThresholdDivisor);
3213
3214 /** @brief Command description for PublishPriceMatrix
3215  *
3216  * Command: PublishPriceMatrix
3217  * @param providerId INT32U
3218  * @param earliestStartTime UTC_TIME
3219  * @param issuerEventId INT32U
3220  * @param minIssuerEventId INT32U
3221  * @param startTime UTC_TIME
3222  * @param numberOfCommands INT8U
3223  * @param issuerTariffId INT32U
3224  * @param commandIndex INT8U
3225  * @param numberOfCommands INT8U
3226  * @param subPayloadControl PriceMatrixSubPayloadControl
3227  * @param payload PriceMatrixSubPayload []
3228  * @param payloadLen int
3229  */
3230 #define emberAfFillCommandPriceClusterPublishPriceMatrix(providerId, earliestStartTime, issuerEventId, minIssuerEventId,           \
3231                                                          startTime, numberOfCommands, issuerTariffId, commandIndex,                \
3232                                                          numberOfCommands, subPayloadControl, payload, payloadLen)                 \
3233     emberAfFillExternalBuffer(mask,                                                                                                \
3234                                                                                                                                    \
3235                               ZCL_PUBLISH_PRICE_MATRIX_COMMAND_ID, "uuuuuuuuuub", providerId, earliestStartTime, issuerEventId,    \
3236                               minIssuerEventId, startTime, numberOfCommands, issuerTariffId, commandIndex, numberOfCommands,       \
3237                               subPayloadControl, payload, payloadLen);
3238
3239 /** @brief Command description for PublishBlockThresholds
3240  *
3241  * Command: PublishBlockThresholds
3242  * @param providerId INT32U
3243  * @param earliestStartTime UTC_TIME
3244  * @param issuerEventId INT32U
3245  * @param minIssuerEventId INT32U
3246  * @param startTime UTC_TIME
3247  * @param numberOfCommands INT8U
3248  * @param issuerTariffId INT32U
3249  * @param tariffType TariffType
3250  * @param commandIndex INT8U
3251  * @param numberOfCommands INT8U
3252  * @param subPayloadControl BlockThresholdSubPayloadControl
3253  * @param payload BlockThresholdSubPayload []
3254  * @param payloadLen int
3255  */
3256 #define emberAfFillCommandPriceClusterPublishBlockThresholds(                                                                      \
3257     providerId, earliestStartTime, issuerEventId, minIssuerEventId, startTime, numberOfCommands, issuerTariffId, tariffType,       \
3258     commandIndex, numberOfCommands, subPayloadControl, payload, payloadLen)                                                        \
3259     emberAfFillExternalBuffer(mask,                                                                                                \
3260                                                                                                                                    \
3261                               ZCL_PUBLISH_BLOCK_THRESHOLDS_COMMAND_ID, "uuuuuuuuuuub", providerId, earliestStartTime,              \
3262                               issuerEventId, minIssuerEventId, startTime, numberOfCommands, issuerTariffId, tariffType,            \
3263                               commandIndex, numberOfCommands, subPayloadControl, payload, payloadLen);
3264
3265 /** @brief Command description for PublishCO2Value
3266  *
3267  * Command: PublishCO2Value
3268  * @param providerId INT32U
3269  * @param issuerTariffId INT32U
3270  * @param issuerEventId INT32U
3271  * @param startTime UTC_TIME
3272  * @param tariffType TariffType
3273  * @param cO2Value INT32U
3274  * @param cO2ValueUnit CO2Unit
3275  * @param cO2ValueTrailingDigit CO2TrailingDigit
3276  */
3277 #define emberAfFillCommandPriceClusterPublishCO2Value(providerId, issuerTariffId, issuerEventId, startTime, tariffType, cO2Value,  \
3278                                                       cO2ValueUnit, cO2ValueTrailingDigit)                                         \
3279     emberAfFillExternalBuffer(mask,                                                                                                \
3280                                                                                                                                    \
3281                               ZCL_PUBLISH_CO2_VALUE_COMMAND_ID, "uuuuuuuu", providerId, issuerTariffId, issuerEventId, startTime,  \
3282                               tariffType, cO2Value, cO2ValueUnit, cO2ValueTrailingDigit);
3283
3284 /** @brief Command description for PublishTierLabels
3285  *
3286  * Command: PublishTierLabels
3287  * @param providerId INT32U
3288  * @param issuerTariffId INT32U
3289  * @param issuerEventId INT32U
3290  * @param issuerTariffId INT32U
3291  * @param commandIndex INT8U
3292  * @param numberOfCommands INT8U
3293  * @param numberOfLabels INT8U
3294  * @param tierLabelsPayload INT8U []
3295  * @param tierLabelsPayloadLen int
3296  */
3297 #define emberAfFillCommandPriceClusterPublishTierLabels(providerId, issuerTariffId, issuerEventId, issuerTariffId, commandIndex,   \
3298                                                         numberOfCommands, numberOfLabels, tierLabelsPayload, tierLabelsPayloadLen) \
3299     emberAfFillExternalBuffer(mask,                                                                                                \
3300                                                                                                                                    \
3301                               ZCL_PUBLISH_TIER_LABELS_COMMAND_ID, "uuuuuuub", providerId, issuerTariffId, issuerEventId,           \
3302                               issuerTariffId, commandIndex, numberOfCommands, numberOfLabels, tierLabelsPayload,                   \
3303                               tierLabelsPayloadLen);
3304
3305 /** @brief Command description for PublishBillingPeriod
3306  *
3307  * Command: PublishBillingPeriod
3308  * @param providerId INT32U
3309  * @param earliestStartTime UTC_TIME
3310  * @param issuerEventId INT32U
3311  * @param minIssuerEventId INT32U
3312  * @param billingPeriodStartTime UTC_TIME
3313  * @param numberOfCommands INT8U
3314  * @param billingPeriodDuration BillingPeriodDuration
3315  * @param tariffType TariffType
3316  * @param billingPeriodDurationType BillingPeriodDurationType
3317  * @param tariffType TariffType
3318  */
3319 #define emberAfFillCommandPriceClusterPublishBillingPeriod(providerId, earliestStartTime, issuerEventId, minIssuerEventId,         \
3320                                                            billingPeriodStartTime, numberOfCommands, billingPeriodDuration,        \
3321                                                            tariffType, billingPeriodDurationType, tariffType)                      \
3322     emberAfFillExternalBuffer(mask,                                                                                                \
3323                                                                                                                                    \
3324                               ZCL_PUBLISH_BILLING_PERIOD_COMMAND_ID, "uuuuuuuuuu", providerId, earliestStartTime, issuerEventId,   \
3325                               minIssuerEventId, billingPeriodStartTime, numberOfCommands, billingPeriodDuration, tariffType,       \
3326                               billingPeriodDurationType, tariffType);
3327
3328 /** @brief Command description for PublishConsolidatedBill
3329  *
3330  * Command: PublishConsolidatedBill
3331  * @param providerId INT32U
3332  * @param issuerTariffId INT32U
3333  * @param issuerEventId INT32U
3334  * @param billingPeriodStartTime UTC_TIME
3335  * @param billingPeriodDuration BillingPeriodDuration
3336  * @param billingPeriodDurationType BillingPeriodDurationType
3337  * @param tariffType TariffType
3338  * @param consolidatedBill INT32U
3339  * @param currency INT16U
3340  * @param billTrailingDigit BillTrailingDigit
3341  */
3342 #define emberAfFillCommandPriceClusterPublishConsolidatedBill(providerId, issuerTariffId, issuerEventId, billingPeriodStartTime,   \
3343                                                               billingPeriodDuration, billingPeriodDurationType, tariffType,        \
3344                                                               consolidatedBill, currency, billTrailingDigit)                       \
3345     emberAfFillExternalBuffer(mask,                                                                                                \
3346                                                                                                                                    \
3347                               ZCL_PUBLISH_CONSOLIDATED_BILL_COMMAND_ID, "uuuuuuuuuu", providerId, issuerTariffId, issuerEventId,   \
3348                               billingPeriodStartTime, billingPeriodDuration, billingPeriodDurationType, tariffType,                \
3349                               consolidatedBill, currency, billTrailingDigit);
3350
3351 /** @brief Command description for PublishCppEvent
3352  *
3353  * Command: PublishCppEvent
3354  * @param providerId INT32U
3355  * @param earliestStartTime UTC_TIME
3356  * @param issuerEventId INT32U
3357  * @param minIssuerEventId INT32U
3358  * @param startTime UTC_TIME
3359  * @param numberOfCommands INT8U
3360  * @param durationInMinutes INT16U
3361  * @param tariffType TariffType
3362  * @param tariffType TariffType
3363  * @param cppPriceTier CppPriceTier
3364  * @param cppAuth PublishCppEventCppAuth
3365  */
3366 #define emberAfFillCommandPriceClusterPublishCppEvent(providerId, earliestStartTime, issuerEventId, minIssuerEventId, startTime,   \
3367                                                       numberOfCommands, durationInMinutes, tariffType, tariffType, cppPriceTier,   \
3368                                                       cppAuth)                                                                     \
3369     emberAfFillExternalBuffer(mask,                                                                                                \
3370                                                                                                                                    \
3371                               ZCL_PUBLISH_CPP_EVENT_COMMAND_ID, "uuuuuuuuuuu", providerId, earliestStartTime, issuerEventId,       \
3372                               minIssuerEventId, startTime, numberOfCommands, durationInMinutes, tariffType, tariffType,            \
3373                               cppPriceTier, cppAuth);
3374
3375 /** @brief Command description for PublishCreditPayment
3376  *
3377  * Command: PublishCreditPayment
3378  * @param providerId INT32U
3379  * @param earliestStartTime UTC_TIME
3380  * @param issuerEventId INT32U
3381  * @param minIssuerEventId INT32U
3382  * @param creditPaymentDueDate UTC_TIME
3383  * @param numberOfCommands INT8U
3384  * @param creditPaymentOverDueAmount INT32U
3385  * @param tariffType TariffType
3386  * @param creditPaymentStatus CreditPaymentStatus
3387  * @param creditPayment INT32U
3388  * @param creditPaymentDate UTC_TIME
3389  * @param creditPaymentRef OCTET_STRING
3390  */
3391 #define emberAfFillCommandPriceClusterPublishCreditPayment(                                                                        \
3392     providerId, earliestStartTime, issuerEventId, minIssuerEventId, creditPaymentDueDate, numberOfCommands,                        \
3393     creditPaymentOverDueAmount, tariffType, creditPaymentStatus, creditPayment, creditPaymentDate, creditPaymentRef)               \
3394     emberAfFillExternalBuffer(mask,                                                                                                \
3395                                                                                                                                    \
3396                               ZCL_PUBLISH_CREDIT_PAYMENT_COMMAND_ID, "uuuuuuuuuuuu", providerId, earliestStartTime, issuerEventId, \
3397                               minIssuerEventId, creditPaymentDueDate, numberOfCommands, creditPaymentOverDueAmount, tariffType,    \
3398                               creditPaymentStatus, creditPayment, creditPaymentDate, creditPaymentRef);
3399
3400 /** @brief Command description for PublishCurrencyConversion
3401  *
3402  * Command: PublishCurrencyConversion
3403  * @param providerId INT32U
3404  * @param issuerEventId INT32U
3405  * @param issuerEventId INT32U
3406  * @param cppAuth CppEventResponseCppAuth
3407  * @param startTime UTC_TIME
3408  * @param oldCurrency INT16U
3409  * @param newCurrency INT16U
3410  * @param conversionFactor INT32U
3411  * @param conversionFactorTrailingDigit ConversionFactorTrailingDigit
3412  * @param currencyChangeControlFlags CurrencyChangeControl
3413  */
3414 #define emberAfFillCommandPriceClusterPublishCurrencyConversion(providerId, issuerEventId, issuerEventId, cppAuth, startTime,      \
3415                                                                 oldCurrency, newCurrency, conversionFactor,                        \
3416                                                                 conversionFactorTrailingDigit, currencyChangeControlFlags)         \
3417     emberAfFillExternalBuffer(mask,                                                                                                \
3418                                                                                                                                    \
3419                               ZCL_PUBLISH_CURRENCY_CONVERSION_COMMAND_ID, "uuuuuuuuuu", providerId, issuerEventId, issuerEventId,  \
3420                               cppAuth, startTime, oldCurrency, newCurrency, conversionFactor, conversionFactorTrailingDigit,       \
3421                               currencyChangeControlFlags);
3422
3423 /** @brief Command description for CancelTariff
3424  *
3425  * Command: CancelTariff
3426  * @param providerId INT32U
3427  * @param latestEndTime UTC_TIME
3428  * @param issuerTariffId INT32U
3429  * @param numberOfRecords INT8U
3430  * @param tariffType TariffType
3431  */
3432 #define emberAfFillCommandPriceClusterCancelTariff(providerId, latestEndTime, issuerTariffId, numberOfRecords, tariffType)         \
3433     emberAfFillExternalBuffer(mask,                                                                                                \
3434                                                                                                                                    \
3435                               ZCL_CANCEL_TARIFF_COMMAND_ID, "uuuuu", providerId, latestEndTime, issuerTariffId, numberOfRecords,   \
3436                               tariffType);
3437
3438 /** @brief Command description for GetCurrencyConversionCommand
3439  *
3440  * Command: GetCurrencyConversionCommand
3441  */
3442 #define emberAfFillCommandPriceClusterGetCurrencyConversionCommand()                                                               \
3443     emberAfFillExternalBuffer(mask,                                                                                                \
3444                                                                                                                                    \
3445                               ZCL_GET_CURRENCY_CONVERSION_COMMAND_COMMAND_ID, "", );
3446
3447 /** @brief Command description for GetTariffCancellation
3448  *
3449  * Command: GetTariffCancellation
3450  */
3451 #define emberAfFillCommandPriceClusterGetTariffCancellation()                                                                      \
3452     emberAfFillExternalBuffer(mask,                                                                                                \
3453                                                                                                                                    \
3454                               ZCL_GET_TARIFF_CANCELLATION_COMMAND_ID, "", );
3455
3456 /** @brief Command description for LoadControlEvent
3457  *
3458  * Command: LoadControlEvent
3459  * @param issuerEventId INT32U
3460  * @param issuerEventId INT32U
3461  * @param deviceClass AmiDeviceClass
3462  * @param eventStatus AmiEventStatus
3463  * @param utilityEnrollmentGroup INT8U
3464  * @param eventStatusTime UTC_TIME
3465  * @param startTime UTC_TIME
3466  * @param criticalityLevelApplied AmiCriticalityLevel
3467  * @param durationInMinutes INT16U
3468  * @param coolingTemperatureSetPointApplied INT16U
3469  * @param criticalityLevel AmiCriticalityLevel
3470  * @param heatingTemperatureSetPointApplied INT16U
3471  * @param coolingTemperatureOffset INT8U
3472  * @param averageLoadAdjustmentPercentageApplied INT8S
3473  * @param heatingTemperatureOffset INT8U
3474  * @param dutyCycleApplied INT8U
3475  * @param coolingTemperatureSetPoint INT16S
3476  * @param eventControl AmiEventControl
3477  * @param heatingTemperatureSetPoint INT16S
3478  * @param signatureType SignatureType
3479  * @param averageLoadAdjustmentPercentage INT8S
3480  * @param signature Signature
3481  * @param dutyCycle INT8U
3482  * @param eventControl AmiEventControl
3483  */
3484 #define emberAfFillCommandDemand                                                                                                   \
3485     Response and Load ControlClusterLoadControlEvent(                                                                              \
3486         issuerEventId, issuerEventId, deviceClass, eventStatus, utilityEnrollmentGroup, eventStatusTime, startTime,                \
3487         criticalityLevelApplied, durationInMinutes, coolingTemperatureSetPointApplied, criticalityLevel,                           \
3488         heatingTemperatureSetPointApplied, coolingTemperatureOffset, averageLoadAdjustmentPercentageApplied,                       \
3489         heatingTemperatureOffset, dutyCycleApplied, coolingTemperatureSetPoint, eventControl, heatingTemperatureSetPoint,          \
3490         signatureType, averageLoadAdjustmentPercentage, signature, dutyCycle, eventControl)                                        \
3491         emberAfFillExternalBuffer(mask,                                                                                            \
3492                                                                                                                                    \
3493                                   ZCL_LOAD_CONTROL_EVENT_COMMAND_ID, "uuuuuuuuuuuuuuuuuuuuuuuu", issuerEventId, issuerEventId,     \
3494                                   deviceClass, eventStatus, utilityEnrollmentGroup, eventStatusTime, startTime,                    \
3495                                   criticalityLevelApplied, durationInMinutes, coolingTemperatureSetPointApplied, criticalityLevel, \
3496                                   heatingTemperatureSetPointApplied, coolingTemperatureOffset,                                     \
3497                                   averageLoadAdjustmentPercentageApplied, heatingTemperatureOffset, dutyCycleApplied,              \
3498                                   coolingTemperatureSetPoint, eventControl, heatingTemperatureSetPoint, signatureType,             \
3499                                   averageLoadAdjustmentPercentage, signature, dutyCycle, eventControl);
3500
3501 /** @brief Command description for CancelLoadControlEvent
3502  *
3503  * Command: CancelLoadControlEvent
3504  * @param issuerEventId INT32U
3505  * @param startTime UTC_TIME
3506  * @param deviceClass AmiDeviceClass
3507  * @param numberOfEvents INT8U
3508  * @param utilityEnrollmentGroup INT8U
3509  * @param issuerEventId INT32U
3510  * @param cancelControl AmiCancelControl
3511  * @param effectiveTime UTC_TIME
3512  */
3513 #define emberAfFillCommandDemand                                                                                                   \
3514     Response and Load ControlClusterCancelLoadControlEvent(issuerEventId, startTime, deviceClass, numberOfEvents,                  \
3515                                                            utilityEnrollmentGroup, issuerEventId, cancelControl, effectiveTime)    \
3516         emberAfFillExternalBuffer(mask,                                                                                            \
3517                                                                                                                                    \
3518                                   ZCL_CANCEL_LOAD_CONTROL_EVENT_COMMAND_ID, "uuuuuuuu", issuerEventId, startTime, deviceClass,     \
3519                                   numberOfEvents, utilityEnrollmentGroup, issuerEventId, cancelControl, effectiveTime);
3520
3521 /** @brief Command description for CancelAllLoadControlEvents
3522  *
3523  * Command: CancelAllLoadControlEvents
3524  * @param cancelControl AmiCancelControl
3525  */
3526 #define emberAfFillCommandDemand                                                                                                   \
3527     Response and Load ControlClusterCancelAllLoadControlEvents(cancelControl)                                                      \
3528         emberAfFillExternalBuffer(mask,                                                                                            \
3529                                                                                                                                    \
3530                                   ZCL_CANCEL_ALL_LOAD_CONTROL_EVENTS_COMMAND_ID, "u", cancelControl);
3531
3532 /** @brief Command description for GetProfileResponse
3533  *
3534  * Command: GetProfileResponse
3535  * @param endTime UTC_TIME
3536  * @param intervalChannel AmiIntervalChannel
3537  * @param status AmiGetProfileStatus
3538  * @param endTime UTC_TIME
3539  * @param profileIntervalPeriod AmiIntervalPeriod
3540  * @param numberOfPeriods INT8U
3541  * @param numberOfPeriodsDelivered INT8U
3542  * @param intervals INT24U []
3543  * @param intervalsLen int
3544  */
3545 #define emberAfFillCommandSimple                                                                                                   \
3546     MeteringClusterGetProfileResponse(endTime, intervalChannel, status, endTime, profileIntervalPeriod, numberOfPeriods,           \
3547                                       numberOfPeriodsDelivered, intervals, intervalsLen)                                           \
3548         emberAfFillExternalBuffer(mask,                                                                                            \
3549                                                                                                                                    \
3550                                   ZCL_GET_PROFILE_RESPONSE_COMMAND_ID, "uuuuuuub", endTime, intervalChannel, status, endTime,      \
3551                                   profileIntervalPeriod, numberOfPeriods, numberOfPeriodsDelivered, intervals, intervalsLen);
3552
3553 /** @brief Command description for RequestMirror
3554  *
3555  * Command: RequestMirror
3556  * @param endpointId INT16U
3557  */
3558 #define emberAfFillCommandSimple                                                                                                   \
3559     MeteringClusterRequestMirror(endpointId) emberAfFillExternalBuffer(mask,                                                       \
3560                                                                                                                                    \
3561                                                                        ZCL_REQUEST_MIRROR_COMMAND_ID, "u", endpointId);
3562
3563 /** @brief Command description for RemoveMirror
3564  *
3565  * Command: RemoveMirror
3566  * @param endpointId INT16U
3567  */
3568 #define emberAfFillCommandSimple                                                                                                   \
3569     MeteringClusterRemoveMirror(endpointId) emberAfFillExternalBuffer(mask,                                                        \
3570                                                                                                                                    \
3571                                                                       ZCL_REMOVE_MIRROR_COMMAND_ID, "u", endpointId);
3572
3573 /** @brief Command description for RequestFastPollModeResponse
3574  *
3575  * Command: RequestFastPollModeResponse
3576  * @param appliedUpdatePeriod INT8U
3577  * @param fastPollUpdatePeriod INT8U
3578  * @param fastPollModeEndtime UTC_TIME
3579  * @param duration INT8U
3580  */
3581 #define emberAfFillCommandSimple                                                                                                   \
3582     MeteringClusterRequestFastPollModeResponse(appliedUpdatePeriod, fastPollUpdatePeriod, fastPollModeEndtime, duration)           \
3583         emberAfFillExternalBuffer(mask,                                                                                            \
3584                                                                                                                                    \
3585                                   ZCL_REQUEST_FAST_POLL_MODE_RESPONSE_COMMAND_ID, "uuuu", appliedUpdatePeriod,                     \
3586                                   fastPollUpdatePeriod, fastPollModeEndtime, duration);
3587
3588 /** @brief Command description for ScheduleSnapshotResponse
3589  *
3590  * Command: ScheduleSnapshotResponse
3591  * @param issuerEventId INT32U
3592  * @param issuerEventId INT32U
3593  * @param snapshotResponsePayload SnapshotResponsePayload []
3594  * @param snapshotResponsePayloadLen int
3595  * @param commandIndex INT8U
3596  * @param commandCount INT8U
3597  * @param snapshotSchedulePayload SnapshotSchedulePayload []
3598  * @param snapshotSchedulePayloadLen int
3599  */
3600 #define emberAfFillCommandSimple                                                                                                   \
3601     MeteringClusterScheduleSnapshotResponse(issuerEventId, issuerEventId, snapshotResponsePayload, snapshotResponsePayloadLen,     \
3602                                             commandIndex, commandCount, snapshotSchedulePayload, snapshotSchedulePayloadLen)       \
3603         emberAfFillExternalBuffer(mask,                                                                                            \
3604                                                                                                                                    \
3605                                   ZCL_SCHEDULE_SNAPSHOT_RESPONSE_COMMAND_ID, "uubuub", issuerEventId, issuerEventId,               \
3606                                   snapshotResponsePayload, snapshotResponsePayloadLen, commandIndex, commandCount,                 \
3607                                   snapshotSchedulePayload, snapshotSchedulePayloadLen);
3608
3609 /** @brief Command description for TakeSnapshotResponse
3610  *
3611  * Command: TakeSnapshotResponse
3612  * @param snapshotId INT32U
3613  * @param snapshotCause SnapshotCause
3614  * @param snapshotConfirmation SnapshotConfirmation
3615  */
3616 #define emberAfFillCommandSimple                                                                                                   \
3617     MeteringClusterTakeSnapshotResponse(snapshotId, snapshotCause, snapshotConfirmation)                                           \
3618         emberAfFillExternalBuffer(mask,                                                                                            \
3619                                                                                                                                    \
3620                                   ZCL_TAKE_SNAPSHOT_RESPONSE_COMMAND_ID, "uuu", snapshotId, snapshotCause, snapshotConfirmation);
3621
3622 /** @brief Command description for PublishSnapshot
3623  *
3624  * Command: PublishSnapshot
3625  * @param snapshotId INT32U
3626  * @param earliestStartTime UTC_TIME
3627  * @param snapshotTime UTC_TIME
3628  * @param latestEndTime UTC_TIME
3629  * @param totalSnapshotsFound INT8U
3630  * @param snapshotOffset INT8U
3631  * @param commandIndex INT8U
3632  * @param snapshotCause SnapshotCause
3633  * @param totalCommands INT8U
3634  * @param snapshotCause SnapshotCause
3635  * @param snapshotPayloadType SnapshotPayloadType
3636  * @param snapshotPayload INT8U []
3637  * @param snapshotPayloadLen int
3638  */
3639 #define emberAfFillCommandSimple                                                                                                   \
3640     MeteringClusterPublishSnapshot(snapshotId, earliestStartTime, snapshotTime, latestEndTime, totalSnapshotsFound,                \
3641                                    snapshotOffset, commandIndex, snapshotCause, totalCommands, snapshotCause, snapshotPayloadType, \
3642                                    snapshotPayload, snapshotPayloadLen)                                                            \
3643         emberAfFillExternalBuffer(mask,                                                                                            \
3644                                                                                                                                    \
3645                                   ZCL_PUBLISH_SNAPSHOT_COMMAND_ID, "uuuuuuuuuuub", snapshotId, earliestStartTime, snapshotTime,    \
3646                                   latestEndTime, totalSnapshotsFound, snapshotOffset, commandIndex, snapshotCause, totalCommands,  \
3647                                   snapshotCause, snapshotPayloadType, snapshotPayload, snapshotPayloadLen);
3648
3649 /** @brief Command description for GetSampledDataResponse
3650  *
3651  * Command: GetSampledDataResponse
3652  * @param sampleId INT16U
3653  * @param issuerEventId INT32U
3654  * @param sampleStartTime UTC_TIME
3655  * @param startSamplingTime UTC_TIME
3656  * @param sampleType SampleType
3657  * @param sampleType SampleType
3658  * @param sampleRequestInterval INT16U
3659  * @param sampleRequestInterval INT16U
3660  * @param numberOfSamples INT16U
3661  * @param maxNumberOfSamples INT16U
3662  * @param samples INT24U []
3663  * @param samplesLen int
3664  */
3665 #define emberAfFillCommandSimple                                                                                                   \
3666     MeteringClusterGetSampledDataResponse(sampleId, issuerEventId, sampleStartTime, startSamplingTime, sampleType, sampleType,     \
3667                                           sampleRequestInterval, sampleRequestInterval, numberOfSamples, maxNumberOfSamples,       \
3668                                           samples, samplesLen)                                                                     \
3669         emberAfFillExternalBuffer(mask,                                                                                            \
3670                                                                                                                                    \
3671                                   ZCL_GET_SAMPLED_DATA_RESPONSE_COMMAND_ID, "uuuuuuuuuub", sampleId, issuerEventId,                \
3672                                   sampleStartTime, startSamplingTime, sampleType, sampleType, sampleRequestInterval,               \
3673                                   sampleRequestInterval, numberOfSamples, maxNumberOfSamples, samples, samplesLen);
3674
3675 /** @brief Command description for ConfigureMirror
3676  *
3677  * Command: ConfigureMirror
3678  * @param issuerEventId INT32U
3679  * @param sampleId INT16U
3680  * @param reportingInterval INT24U
3681  * @param earliestSampleTime UTC_TIME
3682  * @param mirrorNotificationReporting BOOLEAN
3683  * @param sampleType SampleType
3684  * @param notificationScheme INT8U
3685  * @param numberOfSamples INT16U
3686  */
3687 #define emberAfFillCommandSimple                                                                                                   \
3688     MeteringClusterConfigureMirror(issuerEventId, sampleId, reportingInterval, earliestSampleTime, mirrorNotificationReporting,    \
3689                                    sampleType, notificationScheme, numberOfSamples)                                                \
3690         emberAfFillExternalBuffer(mask,                                                                                            \
3691                                                                                                                                    \
3692                                   ZCL_CONFIGURE_MIRROR_COMMAND_ID, "uuuuuuuu", issuerEventId, sampleId, reportingInterval,         \
3693                                   earliestSampleTime, mirrorNotificationReporting, sampleType, notificationScheme,                 \
3694                                   numberOfSamples);
3695
3696 /** @brief Command description for ConfigureNotificationScheme
3697  *
3698  * Command: ConfigureNotificationScheme
3699  * @param issuerEventId INT32U
3700  * @param notificationScheme INT8U
3701  * @param notificationScheme INT8U
3702  * @param notificationFlags BITMAP32 []
3703  * @param notificationFlagsLen int
3704  * @param notificationFlagOrder BITMAP32
3705  */
3706 #define emberAfFillCommandSimple                                                                                                   \
3707     MeteringClusterConfigureNotificationScheme(issuerEventId, notificationScheme, notificationScheme, notificationFlags,           \
3708                                                notificationFlagsLen, notificationFlagOrder)                                        \
3709         emberAfFillExternalBuffer(mask,                                                                                            \
3710                                                                                                                                    \
3711                                   ZCL_CONFIGURE_NOTIFICATION_SCHEME_COMMAND_ID, "uuubu", issuerEventId, notificationScheme,        \
3712                                   notificationScheme, notificationFlags, notificationFlagsLen, notificationFlagOrder);
3713
3714 /** @brief Command description for ConfigureNotificationFlags
3715  *
3716  * Command: ConfigureNotificationFlags
3717  * @param issuerEventId INT32U
3718  * @param providerId INT32U
3719  * @param notificationScheme INT8U
3720  * @param issuerEventId INT32U
3721  * @param notificationFlagAttributeId INT16U
3722  * @param clusterId INT16U
3723  * @param manufacturerCode INT16U
3724  * @param numberOfCommands INT8U
3725  * @param commandIds INT8U []
3726  * @param commandIdsLen int
3727  */
3728 #define emberAfFillCommandSimple                                                                                                   \
3729     MeteringClusterConfigureNotificationFlags(issuerEventId, providerId, notificationScheme, issuerEventId,                        \
3730                                               notificationFlagAttributeId, clusterId, manufacturerCode, numberOfCommands,          \
3731                                               commandIds, commandIdsLen)                                                           \
3732         emberAfFillExternalBuffer(mask,                                                                                            \
3733                                                                                                                                    \
3734                                   ZCL_CONFIGURE_NOTIFICATION_FLAGS_COMMAND_ID, "uuuuuuuub", issuerEventId, providerId,             \
3735                                   notificationScheme, issuerEventId, notificationFlagAttributeId, clusterId, manufacturerCode,     \
3736                                   numberOfCommands, commandIds, commandIdsLen);
3737
3738 /** @brief Command description for GetNotifiedMessage
3739  *
3740  * Command: GetNotifiedMessage
3741  * @param notificationScheme INT8U
3742  * @param providerId INT32U
3743  * @param notificationFlagAttributeId INT16U
3744  * @param issuerEventId INT32U
3745  * @param notificationFlagsN BITMAP32
3746  * @param requestDateTime UTC_TIME
3747  * @param implementationDateTime UTC_TIME
3748  * @param proposedSupplyStatus MeteringSupplyStatus
3749  * @param supplyControlBits SupplyControlBits
3750  */
3751 #define emberAfFillCommandSimple                                                                                                   \
3752     MeteringClusterGetNotifiedMessage(notificationScheme, providerId, notificationFlagAttributeId, issuerEventId,                  \
3753                                       notificationFlagsN, requestDateTime, implementationDateTime, proposedSupplyStatus,           \
3754                                       supplyControlBits)                                                                           \
3755         emberAfFillExternalBuffer(mask,                                                                                            \
3756                                                                                                                                    \
3757                                   ZCL_GET_NOTIFIED_MESSAGE_COMMAND_ID, "uuuuuuuuu", notificationScheme, providerId,                \
3758                                   notificationFlagAttributeId, issuerEventId, notificationFlagsN, requestDateTime,                 \
3759                                   implementationDateTime, proposedSupplyStatus, supplyControlBits);
3760
3761 /** @brief Command description for SupplyStatusResponse
3762  *
3763  * Command: SupplyStatusResponse
3764  * @param providerId INT32U
3765  * @param proposedSupplyStatus ProposedSupplyStatus
3766  * @param issuerEventId INT32U
3767  * @param implementationDateTime UTC_TIME
3768  * @param supplyStatus MeteringSupplyStatus
3769  */
3770 #define emberAfFillCommandSimple                                                                                                   \
3771     MeteringClusterSupplyStatusResponse(providerId, proposedSupplyStatus, issuerEventId, implementationDateTime, supplyStatus)     \
3772         emberAfFillExternalBuffer(mask,                                                                                            \
3773                                                                                                                                    \
3774                                   ZCL_SUPPLY_STATUS_RESPONSE_COMMAND_ID, "uuuuu", providerId, proposedSupplyStatus, issuerEventId, \
3775                                   implementationDateTime, supplyStatus);
3776
3777 /** @brief Command description for StartSamplingResponse
3778  *
3779  * Command: StartSamplingResponse
3780  * @param sampleId INT16U
3781  * @param issuerEventId INT32U
3782  * @param supplyTamperState SupplyStatus
3783  * @param supplyDepletionState SupplyStatus
3784  * @param supplyUncontrolledFlowState SupplyStatus
3785  * @param loadLimitSupplyState SupplyStatus
3786  */
3787 #define emberAfFillCommandSimple                                                                                                   \
3788     MeteringClusterStartSamplingResponse(sampleId, issuerEventId, supplyTamperState, supplyDepletionState,                         \
3789                                          supplyUncontrolledFlowState, loadLimitSupplyState)                                        \
3790         emberAfFillExternalBuffer(mask,                                                                                            \
3791                                                                                                                                    \
3792                                   ZCL_START_SAMPLING_RESPONSE_COMMAND_ID, "uuuuuu", sampleId, issuerEventId, supplyTamperState,    \
3793                                   supplyDepletionState, supplyUncontrolledFlowState, loadLimitSupplyState);
3794
3795 /** @brief Command description for SetUncontrolledFlowThreshold
3796  *
3797  * Command: SetUncontrolledFlowThreshold
3798  * @param providerId INT32U
3799  * @param issuerEventId INT32U
3800  * @param uncontrolledFlowThreshold INT16U
3801  * @param unitOfMeasure AmiUnitOfMeasure
3802  * @param multiplier INT16U
3803  * @param divisor INT16U
3804  * @param stabilisationPeriod INT8U
3805  * @param measurementPeriod INT16U
3806  */
3807 #define emberAfFillCommandSimple                                                                                                   \
3808     MeteringClusterSetUncontrolledFlowThreshold(providerId, issuerEventId, uncontrolledFlowThreshold, unitOfMeasure, multiplier,   \
3809                                                 divisor, stabilisationPeriod, measurementPeriod)                                   \
3810         emberAfFillExternalBuffer(mask,                                                                                            \
3811                                                                                                                                    \
3812                                   ZCL_SET_UNCONTROLLED_FLOW_THRESHOLD_COMMAND_ID, "uuuuuuuu", providerId, issuerEventId,           \
3813                                   uncontrolledFlowThreshold, unitOfMeasure, multiplier, divisor, stabilisationPeriod,              \
3814                                   measurementPeriod);
3815
3816 /** @brief Command description for GetLastMessage
3817  *
3818  * Command: GetLastMessage
3819  * @param messageId INT32U
3820  * @param messageControl MessagingControlMask
3821  * @param startTime UTC_TIME
3822  * @param durationInMinutes INT16U
3823  * @param message CHAR_STRING
3824  * @param optionalExtendedMessageControl MessagingExtendedControlMask
3825  */
3826 #define emberAfFillCommandMessagingClusterGetLastMessage(messageId, messageControl, startTime, durationInMinutes, message,         \
3827                                                          optionalExtendedMessageControl)                                           \
3828     emberAfFillExternalBuffer(mask,                                                                                                \
3829                                                                                                                                    \
3830                               ZCL_GET_LAST_MESSAGE_COMMAND_ID, "uuuuuu", messageId, messageControl, startTime, durationInMinutes,  \
3831                               message, optionalExtendedMessageControl);
3832
3833 /** @brief Command description for CancelMessage
3834  *
3835  * Command: CancelMessage
3836  * @param messageId INT32U
3837  * @param messageId INT32U
3838  * @param messageControl MessagingControlMask
3839  * @param confirmationTime UTC_TIME
3840  * @param messageConfirmationControl BITMAP8
3841  * @param messageResponse OCTET_STRING
3842  */
3843 #define emberAfFillCommandMessagingClusterCancelMessage(messageId, messageId, messageControl, confirmationTime,                    \
3844                                                         messageConfirmationControl, messageResponse)                               \
3845     emberAfFillExternalBuffer(mask,                                                                                                \
3846                                                                                                                                    \
3847                               ZCL_CANCEL_MESSAGE_COMMAND_ID, "uuuuuu", messageId, messageId, messageControl, confirmationTime,     \
3848                               messageConfirmationControl, messageResponse);
3849
3850 /** @brief Command description for DisplayProtectedMessage
3851  *
3852  * Command: DisplayProtectedMessage
3853  * @param messageId INT32U
3854  * @param earliestImplementationTime UTC_TIME
3855  * @param messageControl MessagingControlMask
3856  * @param startTime UTC_TIME
3857  * @param durationInMinutes INT16U
3858  * @param message CHAR_STRING
3859  * @param optionalExtendedMessageControl MessagingExtendedControlMask
3860  */
3861 #define emberAfFillCommandMessagingClusterDisplayProtectedMessage(                                                                 \
3862     messageId, earliestImplementationTime, messageControl, startTime, durationInMinutes, message, optionalExtendedMessageControl)  \
3863     emberAfFillExternalBuffer(mask,                                                                                                \
3864                                                                                                                                    \
3865                               ZCL_DISPLAY_PROTECTED_MESSAGE_COMMAND_ID, "uuuuuuu", messageId, earliestImplementationTime,          \
3866                               messageControl, startTime, durationInMinutes, message, optionalExtendedMessageControl);
3867
3868 /** @brief Command description for CancelAllMessages
3869  *
3870  * Command: CancelAllMessages
3871  * @param implementationDateTime UTC_TIME
3872  */
3873 #define emberAfFillCommandMessagingClusterCancelAllMessages(implementationDateTime)                                                \
3874     emberAfFillExternalBuffer(mask,                                                                                                \
3875                                                                                                                                    \
3876                               ZCL_CANCEL_ALL_MESSAGES_COMMAND_ID, "u", implementationDateTime);
3877
3878 /** @brief Command description for RequestTunnel
3879  *
3880  * Command: RequestTunnel
3881  * @param protocolId INT8U
3882  * @param tunnelId INT16U
3883  * @param manufacturerCode INT16U
3884  * @param tunnelStatus TunnelingTunnelStatus
3885  * @param flowControlSupport BOOLEAN
3886  * @param maximumIncomingTransferSize INT16U
3887  * @param maximumIncomingTransferSize INT16U
3888  */
3889 #define emberAfFillCommandTunnelingClusterRequestTunnel(protocolId, tunnelId, manufacturerCode, tunnelStatus, flowControlSupport,  \
3890                                                         maximumIncomingTransferSize, maximumIncomingTransferSize)                  \
3891     emberAfFillExternalBuffer(mask,                                                                                                \
3892                                                                                                                                    \
3893                               ZCL_REQUEST_TUNNEL_COMMAND_ID, "uuuuuuu", protocolId, tunnelId, manufacturerCode, tunnelStatus,      \
3894                               flowControlSupport, maximumIncomingTransferSize, maximumIncomingTransferSize);
3895
3896 /** @brief Command description for CloseTunnel
3897  *
3898  * Command: CloseTunnel
3899  * @param tunnelId INT16U
3900  * @param tunnelId INT16U
3901  * @param data INT8U []
3902  * @param dataLen int
3903  */
3904 #define emberAfFillCommandTunnelingClusterCloseTunnel(tunnelId, tunnelId, data, dataLen)                                           \
3905     emberAfFillExternalBuffer(mask,                                                                                                \
3906                                                                                                                                    \
3907                               ZCL_CLOSE_TUNNEL_COMMAND_ID, "uub", tunnelId, tunnelId, data, dataLen);
3908
3909 /** @brief Command description for TransferDataClientToServer
3910  *
3911  * Command: TransferDataClientToServer
3912  * @param tunnelId INT16U
3913  * @param tunnelId INT16U
3914  * @param data INT8U []
3915  * @param dataLen int
3916  * @param transferDataStatus TunnelingTransferDataStatus
3917  */
3918 #define emberAfFillCommandTunnelingClusterTransferDataClientToServer(tunnelId, tunnelId, data, dataLen, transferDataStatus)        \
3919     emberAfFillExternalBuffer(mask,                                                                                                \
3920                                                                                                                                    \
3921                               ZCL_TRANSFER_DATA_CLIENT_TO_SERVER_COMMAND_ID, "uubu", tunnelId, tunnelId, data, dataLen,            \
3922                               transferDataStatus);
3923
3924 /** @brief Command description for TransferDataErrorClientToServer
3925  *
3926  * Command: TransferDataErrorClientToServer
3927  * @param tunnelId INT16U
3928  * @param tunnelId INT16U
3929  * @param transferDataStatus TunnelingTransferDataStatus
3930  * @param numberOfBytesLeft INT16U
3931  */
3932 #define emberAfFillCommandTunnelingClusterTransferDataErrorClientToServer(tunnelId, tunnelId, transferDataStatus,                  \
3933                                                                           numberOfBytesLeft)                                       \
3934     emberAfFillExternalBuffer(mask,                                                                                                \
3935                                                                                                                                    \
3936                               ZCL_TRANSFER_DATA_ERROR_CLIENT_TO_SERVER_COMMAND_ID, "uuuu", tunnelId, tunnelId, transferDataStatus, \
3937                               numberOfBytesLeft);
3938
3939 /** @brief Command description for AckTransferDataClientToServer
3940  *
3941  * Command: AckTransferDataClientToServer
3942  * @param tunnelId INT16U
3943  * @param tunnelId INT16U
3944  * @param numberOfBytesLeft INT16U
3945  * @param numberOfOctetsLeft INT16U
3946  */
3947 #define emberAfFillCommandTunnelingClusterAckTransferDataClientToServer(tunnelId, tunnelId, numberOfBytesLeft, numberOfOctetsLeft) \
3948     emberAfFillExternalBuffer(mask,                                                                                                \
3949                                                                                                                                    \
3950                               ZCL_ACK_TRANSFER_DATA_CLIENT_TO_SERVER_COMMAND_ID, "uuuu", tunnelId, tunnelId, numberOfBytesLeft,    \
3951                               numberOfOctetsLeft);
3952
3953 /** @brief Command description for ReadyDataClientToServer
3954  *
3955  * Command: ReadyDataClientToServer
3956  * @param tunnelId INT16U
3957  * @param protocolListComplete BOOLEAN
3958  * @param numberOfOctetsLeft INT16U
3959  * @param protocolCount INT8U
3960  * @param protocolList Protocol []
3961  * @param protocolListLen int
3962  */
3963 #define emberAfFillCommandTunnelingClusterReadyDataClientToServer(tunnelId, protocolListComplete, numberOfOctetsLeft,              \
3964                                                                   protocolCount, protocolList, protocolListLen)                    \
3965     emberAfFillExternalBuffer(mask,                                                                                                \
3966                                                                                                                                    \
3967                               ZCL_READY_DATA_CLIENT_TO_SERVER_COMMAND_ID, "uuuub", tunnelId, protocolListComplete,                 \
3968                               numberOfOctetsLeft, protocolCount, protocolList, protocolListLen);
3969
3970 /** @brief Command description for GetSupportedTunnelProtocols
3971  *
3972  * Command: GetSupportedTunnelProtocols
3973  * @param protocolOffset INT8U
3974  * @param tunnelId INT16U
3975  */
3976 #define emberAfFillCommandTunnelingClusterGetSupportedTunnelProtocols(protocolOffset, tunnelId)                                    \
3977     emberAfFillExternalBuffer(mask,                                                                                                \
3978                                                                                                                                    \
3979                               ZCL_GET_SUPPORTED_TUNNEL_PROTOCOLS_COMMAND_ID, "uu", protocolOffset, tunnelId);
3980
3981 /** @brief Command description for SelectAvailableEmergencyCredit
3982  *
3983  * Command: SelectAvailableEmergencyCredit
3984  * @param commandIssueDateTime UTC_TIME
3985  * @param originatingDevice OriginatingDevice
3986  */
3987 #define emberAfFillCommandPrepaymentClusterSelectAvailableEmergencyCredit(commandIssueDateTime, originatingDevice)                 \
3988     emberAfFillExternalBuffer(mask,                                                                                                \
3989                                                                                                                                    \
3990                               ZCL_SELECT_AVAILABLE_EMERGENCY_CREDIT_COMMAND_ID, "uu", commandIssueDateTime, originatingDevice);
3991
3992 /** @brief Command description for PublishPrepaySnapshot
3993  *
3994  * Command: PublishPrepaySnapshot
3995  * @param snapshotId INT32U
3996  * @param snapshotTime UTC_TIME
3997  * @param totalSnapshotsFound INT8U
3998  * @param commandIndex INT8U
3999  * @param totalNumberOfCommands INT8U
4000  * @param snapshotCause PrepaySnapshotPayloadCause
4001  * @param snapshotPayloadType PrepaySnapshotPayloadType
4002  * @param snapshotPayload INT8U []
4003  * @param snapshotPayloadLen int
4004  */
4005 #define emberAfFillCommandPrepaymentClusterPublishPrepaySnapshot(snapshotId, snapshotTime, totalSnapshotsFound, commandIndex,      \
4006                                                                  totalNumberOfCommands, snapshotCause, snapshotPayloadType,        \
4007                                                                  snapshotPayload, snapshotPayloadLen)                              \
4008     emberAfFillExternalBuffer(mask,                                                                                                \
4009                                                                                                                                    \
4010                               ZCL_PUBLISH_PREPAY_SNAPSHOT_COMMAND_ID, "uuuuuuub", snapshotId, snapshotTime, totalSnapshotsFound,   \
4011                               commandIndex, totalNumberOfCommands, snapshotCause, snapshotPayloadType, snapshotPayload,            \
4012                               snapshotPayloadLen);
4013
4014 /** @brief Command description for ChangeDebt
4015  *
4016  * Command: ChangeDebt
4017  * @param issuerEventId INT32U
4018  * @param friendlyCredit FriendlyCredit
4019  * @param debtLabel OCTET_STRING
4020  * @param friendlyCreditCalendarId INT32U
4021  * @param debtAmount INT32U
4022  * @param emergencyCreditLimit INT32U
4023  * @param debtRecoveryMethod DebtRecoveryMethod
4024  * @param emergencyCreditThreshold INT32U
4025  * @param debtAmountType DebtAmountType
4026  * @param debtRecoveryStartTime UTC_TIME
4027  * @param debtRecoveryCollectionTime INT16U
4028  * @param debtRecoveryFrequency DebtRecoveryFrequency
4029  * @param debtRecoveryAmount INT32U
4030  * @param debtRecoveryBalancePercentage INT16U
4031  */
4032 #define emberAfFillCommandPrepaymentClusterChangeDebt(                                                                             \
4033     issuerEventId, friendlyCredit, debtLabel, friendlyCreditCalendarId, debtAmount, emergencyCreditLimit, debtRecoveryMethod,      \
4034     emergencyCreditThreshold, debtAmountType, debtRecoveryStartTime, debtRecoveryCollectionTime, debtRecoveryFrequency,            \
4035     debtRecoveryAmount, debtRecoveryBalancePercentage)                                                                             \
4036     emberAfFillExternalBuffer(mask,                                                                                                \
4037                                                                                                                                    \
4038                               ZCL_CHANGE_DEBT_COMMAND_ID, "uuuuuuuuuuuuuu", issuerEventId, friendlyCredit, debtLabel,              \
4039                               friendlyCreditCalendarId, debtAmount, emergencyCreditLimit, debtRecoveryMethod,                      \
4040                               emergencyCreditThreshold, debtAmountType, debtRecoveryStartTime, debtRecoveryCollectionTime,         \
4041                               debtRecoveryFrequency, debtRecoveryAmount, debtRecoveryBalancePercentage);
4042
4043 /** @brief Command description for EmergencyCreditSetup
4044  *
4045  * Command: EmergencyCreditSetup
4046  * @param issuerEventId INT32U
4047  * @param resultType ResultType
4048  * @param startTime UTC_TIME
4049  * @param topUpValue INT32U
4050  * @param emergencyCreditLimit INT32U
4051  * @param sourceOfTopUp OriginatingDevice
4052  * @param emergencyCreditThreshold INT32U
4053  * @param creditRemaining INT32U
4054  */
4055 #define emberAfFillCommandPrepaymentClusterEmergencyCreditSetup(issuerEventId, resultType, startTime, topUpValue,                  \
4056                                                                 emergencyCreditLimit, sourceOfTopUp, emergencyCreditThreshold,     \
4057                                                                 creditRemaining)                                                   \
4058     emberAfFillExternalBuffer(mask,                                                                                                \
4059                                                                                                                                    \
4060                               ZCL_EMERGENCY_CREDIT_SETUP_COMMAND_ID, "uuuuuuuu", issuerEventId, resultType, startTime, topUpValue, \
4061                               emergencyCreditLimit, sourceOfTopUp, emergencyCreditThreshold, creditRemaining);
4062
4063 /** @brief Command description for ConsumerTopUp
4064  *
4065  * Command: ConsumerTopUp
4066  * @param originatingDevice OriginatingDevice
4067  * @param topUpCode OCTET_STRING
4068  */
4069 #define emberAfFillCommandPrepaymentClusterConsumerTopUp(originatingDevice, topUpCode)                                             \
4070     emberAfFillExternalBuffer(mask,                                                                                                \
4071                                                                                                                                    \
4072                               ZCL_CONSUMER_TOP_UP_COMMAND_ID, "uu", originatingDevice, topUpCode);
4073
4074 /** @brief Command description for CreditAdjustment
4075  *
4076  * Command: CreditAdjustment
4077  * @param issuerEventId INT32U
4078  * @param commandIndex INT8U
4079  * @param startTime UTC_TIME
4080  * @param totalNumberOfCommands INT8U
4081  * @param creditAdjustmentType CreditAdjustmentType
4082  * @param topUpPayload TopUpPayload []
4083  * @param topUpPayloadLen int
4084  * @param creditAdjustmentValue INT32U
4085  */
4086 #define emberAfFillCommandPrepaymentClusterCreditAdjustment(issuerEventId, commandIndex, startTime, totalNumberOfCommands,         \
4087                                                             creditAdjustmentType, topUpPayload, topUpPayloadLen,                   \
4088                                                             creditAdjustmentValue)                                                 \
4089     emberAfFillExternalBuffer(mask,                                                                                                \
4090                                                                                                                                    \
4091                               ZCL_CREDIT_ADJUSTMENT_COMMAND_ID, "uuuuubu", issuerEventId, commandIndex, startTime,                 \
4092                               totalNumberOfCommands, creditAdjustmentType, topUpPayload, topUpPayloadLen, creditAdjustmentValue);
4093
4094 /** @brief Command description for ChangePaymentMode
4095  *
4096  * Command: ChangePaymentMode
4097  * @param providerId INT32U
4098  * @param commandIndex INT8U
4099  * @param issuerEventId INT32U
4100  * @param totalNumberOfCommands INT8U
4101  * @param implementationDateTime UTC_TIME
4102  * @param debtPayload DebtPayload []
4103  * @param debtPayloadLen int
4104  * @param proposedPaymentControlConfiguration PaymentControlConfiguration
4105  * @param cutOffValue INT32U
4106  */
4107 #define emberAfFillCommandPrepaymentClusterChangePaymentMode(providerId, commandIndex, issuerEventId, totalNumberOfCommands,       \
4108                                                              implementationDateTime, debtPayload, debtPayloadLen,                  \
4109                                                              proposedPaymentControlConfiguration, cutOffValue)                     \
4110     emberAfFillExternalBuffer(mask,                                                                                                \
4111                                                                                                                                    \
4112                               ZCL_CHANGE_PAYMENT_MODE_COMMAND_ID, "uuuuubuu", providerId, commandIndex, issuerEventId,             \
4113                               totalNumberOfCommands, implementationDateTime, debtPayload, debtPayloadLen,                          \
4114                               proposedPaymentControlConfiguration, cutOffValue);
4115
4116 /** @brief Command description for GetPrepaySnapshot
4117  *
4118  * Command: GetPrepaySnapshot
4119  * @param earliestStartTime UTC_TIME
4120  * @param latestEndTime UTC_TIME
4121  * @param snapshotOffset INT8U
4122  * @param snapshotCause PrepaySnapshotPayloadCause
4123  */
4124 #define emberAfFillCommandPrepaymentClusterGetPrepaySnapshot(earliestStartTime, latestEndTime, snapshotOffset, snapshotCause)      \
4125     emberAfFillExternalBuffer(mask,                                                                                                \
4126                                                                                                                                    \
4127                               ZCL_GET_PREPAY_SNAPSHOT_COMMAND_ID, "uuuu", earliestStartTime, latestEndTime, snapshotOffset,        \
4128                               snapshotCause);
4129
4130 /** @brief Command description for GetTopUpLog
4131  *
4132  * Command: GetTopUpLog
4133  * @param latestEndTime UTC_TIME
4134  * @param numberOfRecords INT8U
4135  */
4136 #define emberAfFillCommandPrepaymentClusterGetTopUpLog(latestEndTime, numberOfRecords)                                             \
4137     emberAfFillExternalBuffer(mask,                                                                                                \
4138                                                                                                                                    \
4139                               ZCL_GET_TOP_UP_LOG_COMMAND_ID, "uu", latestEndTime, numberOfRecords);
4140
4141 /** @brief Command description for SetLowCreditWarningLevel
4142  *
4143  * Command: SetLowCreditWarningLevel
4144  * @param lowCreditWarningLevel INT32U
4145  */
4146 #define emberAfFillCommandPrepaymentClusterSetLowCreditWarningLevel(lowCreditWarningLevel)                                         \
4147     emberAfFillExternalBuffer(mask,                                                                                                \
4148                                                                                                                                    \
4149                               ZCL_SET_LOW_CREDIT_WARNING_LEVEL_COMMAND_ID, "u", lowCreditWarningLevel);
4150
4151 /** @brief Command description for GetDebtRepaymentLog
4152  *
4153  * Command: GetDebtRepaymentLog
4154  * @param latestEndTime UTC_TIME
4155  * @param numberOfDebts INT8U
4156  * @param debtType RepaymentDebtType
4157  */
4158 #define emberAfFillCommandPrepaymentClusterGetDebtRepaymentLog(latestEndTime, numberOfDebts, debtType)                             \
4159     emberAfFillExternalBuffer(mask,                                                                                                \
4160                                                                                                                                    \
4161                               ZCL_GET_DEBT_REPAYMENT_LOG_COMMAND_ID, "uuu", latestEndTime, numberOfDebts, debtType);
4162
4163 /** @brief Command description for SetMaximumCreditLimit
4164  *
4165  * Command: SetMaximumCreditLimit
4166  * @param providerId INT32U
4167  * @param issuerEventId INT32U
4168  * @param implementationDateTime UTC_TIME
4169  * @param maximumCreditLevel INT32U
4170  * @param maximumCreditPerTopUp INT32U
4171  */
4172 #define emberAfFillCommandPrepaymentClusterSetMaximumCreditLimit(providerId, issuerEventId, implementationDateTime,                \
4173                                                                  maximumCreditLevel, maximumCreditPerTopUp)                        \
4174     emberAfFillExternalBuffer(mask,                                                                                                \
4175                                                                                                                                    \
4176                               ZCL_SET_MAXIMUM_CREDIT_LIMIT_COMMAND_ID, "uuuuu", providerId, issuerEventId, implementationDateTime, \
4177                               maximumCreditLevel, maximumCreditPerTopUp);
4178
4179 /** @brief Command description for SetOverallDebtCap
4180  *
4181  * Command: SetOverallDebtCap
4182  * @param providerId INT32U
4183  * @param issuerEventId INT32U
4184  * @param implementationDateTime UTC_TIME
4185  * @param overallDebtCap INT32U
4186  */
4187 #define emberAfFillCommandPrepaymentClusterSetOverallDebtCap(providerId, issuerEventId, implementationDateTime, overallDebtCap)    \
4188     emberAfFillExternalBuffer(mask,                                                                                                \
4189                                                                                                                                    \
4190                               ZCL_SET_OVERALL_DEBT_CAP_COMMAND_ID, "uuuu", providerId, issuerEventId, implementationDateTime,      \
4191                               overallDebtCap);
4192
4193 /** @brief Command description for ReportEventStatus
4194  *
4195  * Command: ReportEventStatus
4196  * @param issuerEventId INT32U
4197  * @param issuerEventId INT32U
4198  * @param eventStatus AmiEventStatus
4199  * @param deviceClass AmiDeviceClass
4200  * @param eventStatusTime UTC_TIME
4201  * @param utilityEnrollmentGroup INT8U
4202  * @param criticalityLevelApplied AmiCriticalityLevel
4203  * @param actionRequired INT8U
4204  * @param coolingTemperatureSetPointApplied INT16U
4205  * @param heatingTemperatureSetPointApplied INT16U
4206  * @param averageLoadAdjustmentPercentageApplied INT8S
4207  * @param dutyCycleApplied INT8U
4208  * @param eventControl AmiEventControl
4209  */
4210 #define emberAfFillCommandEnergy                                                                                                   \
4211     ManagementClusterReportEventStatus(issuerEventId, issuerEventId, eventStatus, deviceClass, eventStatusTime,                    \
4212                                        utilityEnrollmentGroup, criticalityLevelApplied, actionRequired,                            \
4213                                        coolingTemperatureSetPointApplied, heatingTemperatureSetPointApplied,                       \
4214                                        averageLoadAdjustmentPercentageApplied, dutyCycleApplied, eventControl)                     \
4215         emberAfFillExternalBuffer(mask,                                                                                            \
4216                                                                                                                                    \
4217                                   ZCL_REPORT_EVENT_STATUS_COMMAND_ID, "uuuuuuuuuuuuu", issuerEventId, issuerEventId, eventStatus,  \
4218                                   deviceClass, eventStatusTime, utilityEnrollmentGroup, criticalityLevelApplied, actionRequired,   \
4219                                   coolingTemperatureSetPointApplied, heatingTemperatureSetPointApplied,                            \
4220                                   averageLoadAdjustmentPercentageApplied, dutyCycleApplied, eventControl);
4221
4222 /** @brief Command description for PublishCalendar
4223  *
4224  * Command: PublishCalendar
4225  * @param providerId INT32U
4226  * @param earliestStartTime UTC_TIME
4227  * @param issuerEventId INT32U
4228  * @param minIssuerEventId INT32U
4229  * @param issuerCalendarId INT32U
4230  * @param numberOfCalendars INT8U
4231  * @param startTime UTC_TIME
4232  * @param calendarType CalendarType
4233  * @param calendarType CalendarType
4234  * @param providerId INT32U
4235  * @param calendarTimeReference CalendarTimeReference
4236  * @param calendarName OCTET_STRING
4237  * @param numberOfSeasons INT8U
4238  * @param numberOfWeekProfiles INT8U
4239  * @param numberOfDayProfiles INT8U
4240  */
4241 #define emberAfFillCommandCalendarClusterPublishCalendar(                                                                          \
4242     providerId, earliestStartTime, issuerEventId, minIssuerEventId, issuerCalendarId, numberOfCalendars, startTime, calendarType,  \
4243     calendarType, providerId, calendarTimeReference, calendarName, numberOfSeasons, numberOfWeekProfiles, numberOfDayProfiles)     \
4244     emberAfFillExternalBuffer(mask,                                                                                                \
4245                                                                                                                                    \
4246                               ZCL_PUBLISH_CALENDAR_COMMAND_ID, "uuuuuuuuuuuuuuu", providerId, earliestStartTime, issuerEventId,    \
4247                               minIssuerEventId, issuerCalendarId, numberOfCalendars, startTime, calendarType, calendarType,        \
4248                               providerId, calendarTimeReference, calendarName, numberOfSeasons, numberOfWeekProfiles,              \
4249                               numberOfDayProfiles);
4250
4251 /** @brief Command description for PublishDayProfile
4252  *
4253  * Command: PublishDayProfile
4254  * @param providerId INT32U
4255  * @param providerId INT32U
4256  * @param issuerEventId INT32U
4257  * @param issuerCalendarId INT32U
4258  * @param issuerCalendarId INT32U
4259  * @param startDayId INT8U
4260  * @param dayId INT8U
4261  * @param numberOfDays INT8U
4262  * @param totalNumberOfScheduleEntries INT8U
4263  * @param commandIndex INT8U
4264  * @param totalNumberOfCommands INT8U
4265  * @param calendarType CalendarType
4266  * @param dayScheduleEntries ScheduleEntry []
4267  * @param dayScheduleEntriesLen int
4268  */
4269 #define emberAfFillCommandCalendarClusterPublishDayProfile(                                                                        \
4270     providerId, providerId, issuerEventId, issuerCalendarId, issuerCalendarId, startDayId, dayId, numberOfDays,                    \
4271     totalNumberOfScheduleEntries, commandIndex, totalNumberOfCommands, calendarType, dayScheduleEntries, dayScheduleEntriesLen)    \
4272     emberAfFillExternalBuffer(mask,                                                                                                \
4273                                                                                                                                    \
4274                               ZCL_PUBLISH_DAY_PROFILE_COMMAND_ID, "uuuuuuuuuuuub", providerId, providerId, issuerEventId,          \
4275                               issuerCalendarId, issuerCalendarId, startDayId, dayId, numberOfDays, totalNumberOfScheduleEntries,   \
4276                               commandIndex, totalNumberOfCommands, calendarType, dayScheduleEntries, dayScheduleEntriesLen);
4277
4278 /** @brief Command description for PublishWeekProfile
4279  *
4280  * Command: PublishWeekProfile
4281  * @param providerId INT32U
4282  * @param providerId INT32U
4283  * @param issuerEventId INT32U
4284  * @param issuerCalendarId INT32U
4285  * @param issuerCalendarId INT32U
4286  * @param startWeekId INT8U
4287  * @param weekId INT8U
4288  * @param numberOfWeeks INT8U
4289  * @param dayIdRefMonday INT8U
4290  * @param dayIdRefTuesday INT8U
4291  * @param dayIdRefWednesday INT8U
4292  * @param dayIdRefThursday INT8U
4293  * @param dayIdRefFriday INT8U
4294  * @param dayIdRefSaturday INT8U
4295  * @param dayIdRefSunday INT8U
4296  */
4297 #define emberAfFillCommandCalendarClusterPublishWeekProfile(                                                                       \
4298     providerId, providerId, issuerEventId, issuerCalendarId, issuerCalendarId, startWeekId, weekId, numberOfWeeks, dayIdRefMonday, \
4299     dayIdRefTuesday, dayIdRefWednesday, dayIdRefThursday, dayIdRefFriday, dayIdRefSaturday, dayIdRefSunday)                        \
4300     emberAfFillExternalBuffer(mask,                                                                                                \
4301                                                                                                                                    \
4302                               ZCL_PUBLISH_WEEK_PROFILE_COMMAND_ID, "uuuuuuuuuuuuuuu", providerId, providerId, issuerEventId,       \
4303                               issuerCalendarId, issuerCalendarId, startWeekId, weekId, numberOfWeeks, dayIdRefMonday,              \
4304                               dayIdRefTuesday, dayIdRefWednesday, dayIdRefThursday, dayIdRefFriday, dayIdRefSaturday,              \
4305                               dayIdRefSunday);
4306
4307 /** @brief Command description for PublishSeasons
4308  *
4309  * Command: PublishSeasons
4310  * @param providerId INT32U
4311  * @param providerId INT32U
4312  * @param issuerEventId INT32U
4313  * @param issuerCalendarId INT32U
4314  * @param issuerCalendarId INT32U
4315  * @param commandIndex INT8U
4316  * @param totalNumberOfCommands INT8U
4317  * @param seasonEntries SeasonEntry []
4318  * @param seasonEntriesLen int
4319  */
4320 #define emberAfFillCommandCalendarClusterPublishSeasons(providerId, providerId, issuerEventId, issuerCalendarId, issuerCalendarId, \
4321                                                         commandIndex, totalNumberOfCommands, seasonEntries, seasonEntriesLen)      \
4322     emberAfFillExternalBuffer(mask,                                                                                                \
4323                                                                                                                                    \
4324                               ZCL_PUBLISH_SEASONS_COMMAND_ID, "uuuuuuub", providerId, providerId, issuerEventId, issuerCalendarId, \
4325                               issuerCalendarId, commandIndex, totalNumberOfCommands, seasonEntries, seasonEntriesLen);
4326
4327 /** @brief Command description for PublishSpecialDays
4328  *
4329  * Command: PublishSpecialDays
4330  * @param providerId INT32U
4331  * @param startTime UTC_TIME
4332  * @param issuerEventId INT32U
4333  * @param numberOfEvents INT8U
4334  * @param issuerCalendarId INT32U
4335  * @param calendarType CalendarType
4336  * @param startTime UTC_TIME
4337  * @param providerId INT32U
4338  * @param calendarType CalendarType
4339  * @param issuerCalendarId INT32U
4340  * @param totalNumberOfSpecialDays INT8U
4341  * @param commandIndex INT8U
4342  * @param totalNumberOfCommands INT8U
4343  * @param specialDayEntries SpecialDay []
4344  * @param specialDayEntriesLen int
4345  */
4346 #define emberAfFillCommandCalendarClusterPublishSpecialDays(                                                                       \
4347     providerId, startTime, issuerEventId, numberOfEvents, issuerCalendarId, calendarType, startTime, providerId, calendarType,     \
4348     issuerCalendarId, totalNumberOfSpecialDays, commandIndex, totalNumberOfCommands, specialDayEntries, specialDayEntriesLen)      \
4349     emberAfFillExternalBuffer(mask,                                                                                                \
4350                                                                                                                                    \
4351                               ZCL_PUBLISH_SPECIAL_DAYS_COMMAND_ID, "uuuuuuuuuuuuub", providerId, startTime, issuerEventId,         \
4352                               numberOfEvents, issuerCalendarId, calendarType, startTime, providerId, calendarType,                 \
4353                               issuerCalendarId, totalNumberOfSpecialDays, commandIndex, totalNumberOfCommands, specialDayEntries,  \
4354                               specialDayEntriesLen);
4355
4356 /** @brief Command description for GetCalendarCancellation
4357  *
4358  * Command: GetCalendarCancellation
4359  * @param providerId INT32U
4360  * @param issuerCalendarId INT32U
4361  * @param calendarType CalendarType
4362  */
4363 #define emberAfFillCommandCalendarClusterGetCalendarCancellation(providerId, issuerCalendarId, calendarType)                       \
4364     emberAfFillExternalBuffer(mask,                                                                                                \
4365                                                                                                                                    \
4366                               ZCL_GET_CALENDAR_CANCELLATION_COMMAND_ID, "uuu", providerId, issuerCalendarId, calendarType);
4367
4368 /** @brief Command description for GetChangeOfTenancy
4369  *
4370  * Command: GetChangeOfTenancy
4371  * @param providerId INT32U
4372  * @param issuerEventId INT32U
4373  * @param tariffType TariffType
4374  * @param implementationDateTime UTC_TIME
4375  * @param proposedTenancyChangeControl ProposedChangeControl
4376  */
4377 #define emberAfFillCommandDevice                                                                                                   \
4378     ManagementClusterGetChangeOfTenancy(providerId, issuerEventId, tariffType, implementationDateTime,                             \
4379                                         proposedTenancyChangeControl)                                                              \
4380         emberAfFillExternalBuffer(mask,                                                                                            \
4381                                                                                                                                    \
4382                                   ZCL_GET_CHANGE_OF_TENANCY_COMMAND_ID, "uuuuu", providerId, issuerEventId, tariffType,            \
4383                                   implementationDateTime, proposedTenancyChangeControl);
4384
4385 /** @brief Command description for GetChangeOfSupplier
4386  *
4387  * Command: GetChangeOfSupplier
4388  * @param currentProviderId INT32U
4389  * @param issuerEventId INT32U
4390  * @param tariffType TariffType
4391  * @param proposedProviderId INT32U
4392  * @param providerChangeImplementationTime UTC_TIME
4393  * @param providerChangeControl ProposedChangeControl
4394  * @param proposedProviderName OCTET_STRING
4395  * @param proposedProviderContactDetails OCTET_STRING
4396  */
4397 #define emberAfFillCommandDevice                                                                                                   \
4398     ManagementClusterGetChangeOfSupplier(currentProviderId, issuerEventId, tariffType, proposedProviderId,                         \
4399                                          providerChangeImplementationTime, providerChangeControl, proposedProviderName,            \
4400                                          proposedProviderContactDetails)                                                           \
4401         emberAfFillExternalBuffer(mask,                                                                                            \
4402                                                                                                                                    \
4403                                   ZCL_GET_CHANGE_OF_SUPPLIER_COMMAND_ID, "uuuuuuuu", currentProviderId, issuerEventId, tariffType, \
4404                                   proposedProviderId, providerChangeImplementationTime, providerChangeControl,                     \
4405                                   proposedProviderName, proposedProviderContactDetails);
4406
4407 /** @brief Command description for RequestNewPassword
4408  *
4409  * Command: RequestNewPassword
4410  * @param passwordType PasswordType
4411  * @param issuerEventId INT32U
4412  * @param implementationDateTime UTC_TIME
4413  * @param durationInMinutes INT16U
4414  * @param passwordType PasswordType
4415  * @param password OCTET_STRING
4416  */
4417 #define emberAfFillCommandDevice                                                                                                   \
4418     ManagementClusterRequestNewPassword(passwordType, issuerEventId, implementationDateTime, durationInMinutes, passwordType,      \
4419                                         password)                                                                                  \
4420         emberAfFillExternalBuffer(mask,                                                                                            \
4421                                                                                                                                    \
4422                                   ZCL_REQUEST_NEW_PASSWORD_COMMAND_ID, "uuuuuu", passwordType, issuerEventId,                      \
4423                                   implementationDateTime, durationInMinutes, passwordType, password);
4424
4425 /** @brief Command description for GetSiteId
4426  *
4427  * Command: GetSiteId
4428  * @param issuerEventId INT32U
4429  * @param siteIdTime UTC_TIME
4430  * @param providerId INT32U
4431  * @param siteId OCTET_STRING
4432  */
4433 #define emberAfFillCommandDevice                                                                                                   \
4434     ManagementClusterGetSiteId(issuerEventId, siteIdTime, providerId, siteId)                                                      \
4435         emberAfFillExternalBuffer(mask,                                                                                            \
4436                                                                                                                                    \
4437                                   ZCL_GET_SITE_ID_COMMAND_ID, "uuuu", issuerEventId, siteIdTime, providerId, siteId);
4438
4439 /** @brief Command description for ReportEventConfiguration
4440  *
4441  * Command: ReportEventConfiguration
4442  * @param commandIndex INT8U
4443  * @param issuerEventId INT32U
4444  * @param totalCommands INT8U
4445  * @param startDateTime UTC_TIME
4446  * @param eventConfigurationPayload EventConfigurationPayload []
4447  * @param eventConfigurationPayloadLen int
4448  * @param eventConfiguration EventConfiguration
4449  * @param configurationControl EventConfigurationControl
4450  * @param eventConfigurationPayload INT8U []
4451  * @param eventConfigurationPayloadLen int
4452  */
4453 #define emberAfFillCommandDevice                                                                                                   \
4454     ManagementClusterReportEventConfiguration(commandIndex, issuerEventId, totalCommands, startDateTime,                           \
4455                                               eventConfigurationPayload, eventConfigurationPayloadLen, eventConfiguration,         \
4456                                               configurationControl, eventConfigurationPayload, eventConfigurationPayloadLen)       \
4457         emberAfFillExternalBuffer(mask,                                                                                            \
4458                                                                                                                                    \
4459                                   ZCL_REPORT_EVENT_CONFIGURATION_COMMAND_ID, "uuuubuub", commandIndex, issuerEventId,              \
4460                                   totalCommands, startDateTime, eventConfigurationPayload, eventConfigurationPayloadLen,           \
4461                                   eventConfiguration, configurationControl, eventConfigurationPayload,                             \
4462                                   eventConfigurationPayloadLen);
4463
4464 /** @brief Command description for GetCIN
4465  *
4466  * Command: GetCIN
4467  * @param eventId INT16U
4468  */
4469 #define emberAfFillCommandDevice                                                                                                   \
4470     ManagementClusterGetCIN(eventId) emberAfFillExternalBuffer(mask,                                                               \
4471                                                                                                                                    \
4472                                                                ZCL_GET_CIN_COMMAND_ID, "u", eventId);
4473
4474 /** @brief Command description for UpdateCIN
4475  *
4476  * Command: UpdateCIN
4477  * @param issuerEventId INT32U
4478  * @param implementationTime UTC_TIME
4479  * @param providerId INT32U
4480  * @param customerIdNumber OCTET_STRING
4481  */
4482 #define emberAfFillCommandDevice                                                                                                   \
4483     ManagementClusterUpdateCIN(issuerEventId, implementationTime, providerId, customerIdNumber) emberAfFillExternalBuffer(         \
4484         mask,                                                                                                                      \
4485                                                                                                                                    \
4486         ZCL_UPDATE_CIN_COMMAND_ID, "uuuu", issuerEventId, implementationTime, providerId, customerIdNumber);
4487
4488 /** @brief Command description for GetEventLog
4489  *
4490  * Command: GetEventLog
4491  * @param eventControlLogId EventControlLogId
4492  * @param logId EventLogId
4493  * @param eventId INT16U
4494  * @param eventId INT16U
4495  * @param startTime UTC_TIME
4496  * @param eventTime UTC_TIME
4497  * @param endTime UTC_TIME
4498  * @param eventControl EventActionControl
4499  * @param numberOfEvents INT8U
4500  * @param eventData OCTET_STRING
4501  * @param eventOffset INT16U
4502  */
4503 #define emberAfFillCommandEventsClusterGetEventLog(eventControlLogId, logId, eventId, eventId, startTime, eventTime, endTime,      \
4504                                                    eventControl, numberOfEvents, eventData, eventOffset)                           \
4505     emberAfFillExternalBuffer(mask,                                                                                                \
4506                                                                                                                                    \
4507                               ZCL_GET_EVENT_LOG_COMMAND_ID, "uuuuuuuuuuu", eventControlLogId, logId, eventId, eventId, startTime,  \
4508                               eventTime, endTime, eventControl, numberOfEvents, eventData, eventOffset);
4509
4510 /** @brief Command description for ClearEventLogRequest
4511  *
4512  * Command: ClearEventLogRequest
4513  * @param logId EventLogId
4514  * @param totalNumberOfEvents INT16U
4515  * @param commandIndex INT8U
4516  * @param totalCommands INT8U
4517  * @param logPayloadControl NumberOfEventsLogPayloadControl
4518  * @param logPayload EventLogPayload []
4519  * @param logPayloadLen int
4520  */
4521 #define emberAfFillCommandEventsClusterClearEventLogRequest(logId, totalNumberOfEvents, commandIndex, totalCommands,               \
4522                                                             logPayloadControl, logPayload, logPayloadLen)                          \
4523     emberAfFillExternalBuffer(mask,                                                                                                \
4524                                                                                                                                    \
4525                               ZCL_CLEAR_EVENT_LOG_REQUEST_COMMAND_ID, "uuuuub", logId, totalNumberOfEvents, commandIndex,          \
4526                               totalCommands, logPayloadControl, logPayload, logPayloadLen);
4527
4528 /** @brief Command description for ClearEventLogResponse
4529  *
4530  * Command: ClearEventLogResponse
4531  * @param clearedEventsLogs ClearedEventsLogs
4532  */
4533 #define emberAfFillCommandEventsClusterClearEventLogResponse(clearedEventsLogs)                                                    \
4534     emberAfFillExternalBuffer(mask,                                                                                                \
4535                                                                                                                                    \
4536                               ZCL_CLEAR_EVENT_LOG_RESPONSE_COMMAND_ID, "u", clearedEventsLogs);
4537
4538 /** @brief Command description for PairingResponse
4539  *
4540  * Command: PairingResponse
4541  * @param pairingInformationVersion INT32U
4542  * @param localPairingInformationVersion INT32U
4543  * @param totalNumberOfDevices INT8U
4544  * @param eui64OfRequestingDevice IEEE_ADDRESS
4545  * @param commandIndex INT8U
4546  * @param totalNumberOfCommands INT8U
4547  * @param eui64s IEEE_ADDRESS []
4548  * @param eui64sLen int
4549  */
4550 #define emberAfFillCommandMDU                                                                                                      \
4551     PairingClusterPairingResponse(pairingInformationVersion, localPairingInformationVersion, totalNumberOfDevices,                 \
4552                                   eui64OfRequestingDevice, commandIndex, totalNumberOfCommands, eui64s, eui64sLen)                 \
4553         emberAfFillExternalBuffer(mask,                                                                                            \
4554                                                                                                                                    \
4555                                   ZCL_PAIRING_RESPONSE_COMMAND_ID, "uuuuuub", pairingInformationVersion,                           \
4556                                   localPairingInformationVersion, totalNumberOfDevices, eui64OfRequestingDevice, commandIndex,     \
4557                                   totalNumberOfCommands, eui64s, eui64sLen);
4558
4559 /** @brief Command description for GetSuspendZclMessagesStatus
4560  *
4561  * Command: GetSuspendZclMessagesStatus
4562  * @param period INT8U
4563  */
4564 #define emberAfFillCommandSub                                                                                                      \
4565     -GHzClusterGetSuspendZclMessagesStatus(period)                                                                                 \
4566         emberAfFillExternalBuffer(mask,                                                                                            \
4567                                                                                                                                    \
4568                                   ZCL_GET_SUSPEND_ZCL_MESSAGES_STATUS_COMMAND_ID, "u", period);
4569
4570 /** @brief Command description for InitiateKeyEstablishmentRequest
4571  *
4572  * Command: InitiateKeyEstablishmentRequest
4573  * @param keyEstablishmentSuite BITMAP16
4574  * @param requestedKeyEstablishmentSuite BITMAP16
4575  * @param ephemeralDataGenerateTime INT8U
4576  * @param ephemeralDataGenerateTime INT8U
4577  * @param confirmKeyGenerateTime INT8U
4578  * @param confirmKeyGenerateTime INT8U
4579  * @param identity Identity
4580  * @param identity Identity
4581  */
4582 #define emberAfFillCommandKey                                                                                                      \
4583     EstablishmentClusterInitiateKeyEstablishmentRequest(keyEstablishmentSuite, requestedKeyEstablishmentSuite,                     \
4584                                                         ephemeralDataGenerateTime, ephemeralDataGenerateTime,                      \
4585                                                         confirmKeyGenerateTime, confirmKeyGenerateTime, identity, identity)        \
4586         emberAfFillExternalBuffer(mask,                                                                                            \
4587                                                                                                                                    \
4588                                   ZCL_INITIATE_KEY_ESTABLISHMENT_REQUEST_COMMAND_ID, "uuuuuuuu", keyEstablishmentSuite,            \
4589                                   requestedKeyEstablishmentSuite, ephemeralDataGenerateTime, ephemeralDataGenerateTime,            \
4590                                   confirmKeyGenerateTime, confirmKeyGenerateTime, identity, identity);
4591
4592 /** @brief Command description for EphemeralDataRequest
4593  *
4594  * Command: EphemeralDataRequest
4595  * @param ephemeralData EphemeralData
4596  * @param ephemeralData EphemeralData
4597  */
4598 #define emberAfFillCommandKey                                                                                                      \
4599     EstablishmentClusterEphemeralDataRequest(ephemeralData, ephemeralData)                                                         \
4600         emberAfFillExternalBuffer(mask,                                                                                            \
4601                                                                                                                                    \
4602                                   ZCL_EPHEMERAL_DATA_REQUEST_COMMAND_ID, "uu", ephemeralData, ephemeralData);
4603
4604 /** @brief Command description for ConfirmKeyDataRequest
4605  *
4606  * Command: ConfirmKeyDataRequest
4607  * @param secureMessageAuthenticationCode Smac
4608  * @param secureMessageAuthenticationCode Smac
4609  */
4610 #define emberAfFillCommandKey                                                                                                      \
4611     EstablishmentClusterConfirmKeyDataRequest(secureMessageAuthenticationCode, secureMessageAuthenticationCode)                    \
4612         emberAfFillExternalBuffer(mask,                                                                                            \
4613                                                                                                                                    \
4614                                   ZCL_CONFIRM_KEY_DATA_REQUEST_COMMAND_ID, "uu", secureMessageAuthenticationCode,                  \
4615                                   secureMessageAuthenticationCode);
4616
4617 /** @brief Command description for TerminateKeyEstablishment
4618  *
4619  * Command: TerminateKeyEstablishment
4620  * @param statusCode AmiKeyEstablishmentStatus
4621  * @param waitTime INT8U
4622  * @param keyEstablishmentSuite BITMAP16
4623  */
4624 #define emberAfFillCommandKey                                                                                                      \
4625     EstablishmentClusterTerminateKeyEstablishment(statusCode, waitTime, keyEstablishmentSuite)                                     \
4626         emberAfFillExternalBuffer(mask,                                                                                            \
4627                                                                                                                                    \
4628                                   ZCL_TERMINATE_KEY_ESTABLISHMENT_COMMAND_ID, "uuu", statusCode, waitTime, keyEstablishmentSuite);
4629
4630 /** @brief Command description for RequestInformation
4631  *
4632  * Command: RequestInformation
4633  * @param inquiryId ENUM8
4634  * @param number INT8U
4635  * @param dataTypeId BITMAP8
4636  * @param buffer INT8U []
4637  * @param bufferLen int
4638  * @param requestInformationPayload INT8U []
4639  * @param requestInformationPayloadLen int
4640  */
4641 #define emberAfFillCommandInformationClusterRequestInformation(inquiryId, number, dataTypeId, buffer, bufferLen,                   \
4642                                                                requestInformationPayload, requestInformationPayloadLen)            \
4643     emberAfFillExternalBuffer(mask,                                                                                                \
4644                                                                                                                                    \
4645                               ZCL_REQUEST_INFORMATION_COMMAND_ID, "uuubb", inquiryId, number, dataTypeId, buffer, bufferLen,       \
4646                               requestInformationPayload, requestInformationPayloadLen);
4647
4648 /** @brief Command description for PushInformationResponse
4649  *
4650  * Command: PushInformationResponse
4651  * @param notificationList Notification []
4652  * @param notificationListLen int
4653  * @param contents INT8U []
4654  * @param contentsLen int
4655  */
4656 #define emberAfFillCommandInformationClusterPushInformationResponse(notificationList, notificationListLen, contents, contentsLen)  \
4657     emberAfFillExternalBuffer(mask,                                                                                                \
4658                                                                                                                                    \
4659                               ZCL_PUSH_INFORMATION_RESPONSE_COMMAND_ID, "bb", notificationList, notificationListLen, contents,     \
4660                               contentsLen);
4661
4662 /** @brief Command description for SendPreference
4663  *
4664  * Command: SendPreference
4665  * @param preferenceType INT16U
4666  * @param statusFeedbackList Status []
4667  * @param statusFeedbackListLen int
4668  * @param preferencePayload INT8U []
4669  * @param preferencePayloadLen int
4670  */
4671 #define emberAfFillCommandInformationClusterSendPreference(preferenceType, statusFeedbackList, statusFeedbackListLen,              \
4672                                                            preferencePayload, preferencePayloadLen)                                \
4673     emberAfFillExternalBuffer(mask,                                                                                                \
4674                                                                                                                                    \
4675                               ZCL_SEND_PREFERENCE_COMMAND_ID, "ubb", preferenceType, statusFeedbackList, statusFeedbackListLen,    \
4676                               preferencePayload, preferencePayloadLen);
4677
4678 /** @brief Command description for ServerRequestPreference
4679  *
4680  * Command: ServerRequestPreference
4681  * @param statusFeedback Status
4682  * @param preferenceType INT16U
4683  * @param preferencePayload INT8U []
4684  * @param preferencePayloadLen int
4685  */
4686 #define emberAfFillCommandInformationClusterServerRequestPreference(statusFeedback, preferenceType, preferencePayload,             \
4687                                                                     preferencePayloadLen)                                          \
4688     emberAfFillExternalBuffer(mask,                                                                                                \
4689                                                                                                                                    \
4690                               ZCL_SERVER_REQUEST_PREFERENCE_COMMAND_ID, "uub", statusFeedback, preferenceType, preferencePayload,  \
4691                               preferencePayloadLen);
4692
4693 /** @brief Command description for Update
4694  *
4695  * Command: Update
4696  * @param accessControl ENUM8
4697  * @param statusFeedbackList Status []
4698  * @param statusFeedbackListLen int
4699  * @param option BITMAP8
4700  * @param contents INT8U []
4701  * @param contentsLen int
4702  */
4703 #define emberAfFillCommandInformationClusterUpdate(accessControl, statusFeedbackList, statusFeedbackListLen, option, contents,     \
4704                                                    contentsLen)                                                                    \
4705     emberAfFillExternalBuffer(mask,                                                                                                \
4706                                                                                                                                    \
4707                               ZCL_UPDATE_COMMAND_ID, "ubub", accessControl, statusFeedbackList, statusFeedbackListLen, option,     \
4708                               contents, contentsLen);
4709
4710 /** @brief Command description for Delete
4711  *
4712  * Command: Delete
4713  * @param deletionOptions BITMAP8
4714  * @param notificationList Notification []
4715  * @param notificationListLen int
4716  * @param contentIds INT16U []
4717  * @param contentIdsLen int
4718  */
4719 #define emberAfFillCommandInformationClusterDelete(deletionOptions, notificationList, notificationListLen, contentIds,             \
4720                                                    contentIdsLen)                                                                  \
4721     emberAfFillExternalBuffer(mask,                                                                                                \
4722                                                                                                                                    \
4723                               ZCL_DELETE_COMMAND_ID, "ubb", deletionOptions, notificationList, notificationListLen, contentIds,    \
4724                               contentIdsLen);
4725
4726 /** @brief Command description for ConfigureNodeDescription
4727  *
4728  * Command: ConfigureNodeDescription
4729  * @param description CHAR_STRING
4730  * @param notificationList Notification []
4731  * @param notificationListLen int
4732  */
4733 #define emberAfFillCommandInformationClusterConfigureNodeDescription(description, notificationList, notificationListLen)           \
4734     emberAfFillExternalBuffer(mask,                                                                                                \
4735                                                                                                                                    \
4736                               ZCL_CONFIGURE_NODE_DESCRIPTION_COMMAND_ID, "ub", description, notificationList,                      \
4737                               notificationListLen);
4738
4739 /** @brief Command description for ConfigureDeliveryEnable
4740  *
4741  * Command: ConfigureDeliveryEnable
4742  * @param enable BOOLEAN
4743  */
4744 #define emberAfFillCommandInformationClusterConfigureDeliveryEnable(enable)                                                        \
4745     emberAfFillExternalBuffer(mask,                                                                                                \
4746                                                                                                                                    \
4747                               ZCL_CONFIGURE_DELIVERY_ENABLE_COMMAND_ID, "u", enable);
4748
4749 /** @brief Command description for ConfigurePushInformationTimer
4750  *
4751  * Command: ConfigurePushInformationTimer
4752  * @param timer INT32U
4753  */
4754 #define emberAfFillCommandInformationClusterConfigurePushInformationTimer(timer)                                                   \
4755     emberAfFillExternalBuffer(mask,                                                                                                \
4756                                                                                                                                    \
4757                               ZCL_CONFIGURE_PUSH_INFORMATION_TIMER_COMMAND_ID, "u", timer);
4758
4759 /** @brief Command description for ConfigureSetRootId
4760  *
4761  * Command: ConfigureSetRootId
4762  * @param rootId INT16U
4763  */
4764 #define emberAfFillCommandInformationClusterConfigureSetRootId(rootId)                                                             \
4765     emberAfFillExternalBuffer(mask,                                                                                                \
4766                                                                                                                                    \
4767                               ZCL_CONFIGURE_SET_ROOT_ID_COMMAND_ID, "u", rootId);
4768
4769 /** @brief Command description for ReadFileRequest
4770  *
4771  * Command: ReadFileRequest
4772  * @param fileIndex INT16U
4773  * @param writeOptions BITMAP8
4774  * @param fileStartPositionAndRequestedOctetCount INT8U []
4775  * @param fileStartPositionAndRequestedOctetCountLen int
4776  * @param fileSize INT8U []
4777  * @param fileSizeLen int
4778  */
4779 #define emberAfFillCommandData                                                                                                     \
4780     SharingClusterReadFileRequest(fileIndex, writeOptions, fileStartPositionAndRequestedOctetCount,                                \
4781                                   fileStartPositionAndRequestedOctetCountLen, fileSize, fileSizeLen)                               \
4782         emberAfFillExternalBuffer(mask,                                                                                            \
4783                                                                                                                                    \
4784                                   ZCL_READ_FILE_REQUEST_COMMAND_ID, "uubb", fileIndex, writeOptions,                               \
4785                                   fileStartPositionAndRequestedOctetCount, fileStartPositionAndRequestedOctetCountLen, fileSize,   \
4786                                   fileSizeLen);
4787
4788 /** @brief Command description for ReadRecordRequest
4789  *
4790  * Command: ReadRecordRequest
4791  * @param fileIndex INT16U
4792  * @param fileIndex INT16U
4793  * @param fileStartRecordAndRequestedRecordCount INT8U []
4794  * @param fileStartRecordAndRequestedRecordCountLen int
4795  * @param fileStartPosition INT32U
4796  * @param octetCount INT32U
4797  */
4798 #define emberAfFillCommandData                                                                                                     \
4799     SharingClusterReadRecordRequest(fileIndex, fileIndex, fileStartRecordAndRequestedRecordCount,                                  \
4800                                     fileStartRecordAndRequestedRecordCountLen, fileStartPosition, octetCount)                      \
4801         emberAfFillExternalBuffer(mask,                                                                                            \
4802                                                                                                                                    \
4803                                   ZCL_READ_RECORD_REQUEST_COMMAND_ID, "uubuu", fileIndex, fileIndex,                               \
4804                                   fileStartRecordAndRequestedRecordCount, fileStartRecordAndRequestedRecordCountLen,               \
4805                                   fileStartPosition, octetCount);
4806
4807 /** @brief Command description for WriteFileResponse
4808  *
4809  * Command: WriteFileResponse
4810  * @param status ENUM8
4811  * @param fileIndex INT16U
4812  * @param fileIndex INT8U []
4813  * @param fileIndexLen int
4814  * @param fileStartRecord INT16U
4815  * @param recordCount INT16U
4816  */
4817 #define emberAfFillCommandData                                                                                                     \
4818     SharingClusterWriteFileResponse(status, fileIndex, fileIndex, fileIndexLen, fileStartRecord, recordCount)                      \
4819         emberAfFillExternalBuffer(mask,                                                                                            \
4820                                                                                                                                    \
4821                                   ZCL_WRITE_FILE_RESPONSE_COMMAND_ID, "uubuu", status, fileIndex, fileIndex, fileIndexLen,         \
4822                                   fileStartRecord, recordCount);
4823
4824 /** @brief Command description for FileTransmission
4825  *
4826  * Command: FileTransmission
4827  * @param transmitOptions BITMAP8
4828  * @param buffer INT8U []
4829  * @param bufferLen int
4830  */
4831 #define emberAfFillCommandData                                                                                                     \
4832     SharingClusterFileTransmission(transmitOptions, buffer, bufferLen)                                                             \
4833         emberAfFillExternalBuffer(mask,                                                                                            \
4834                                                                                                                                    \
4835                                   ZCL_FILE_TRANSMISSION_COMMAND_ID, "ub", transmitOptions, buffer, bufferLen);
4836
4837 /** @brief Command description for RecordTransmission
4838  *
4839  * Command: RecordTransmission
4840  * @param transmitOptions BITMAP8
4841  * @param buffer INT8U []
4842  * @param bufferLen int
4843  */
4844 #define emberAfFillCommandData                                                                                                     \
4845     SharingClusterRecordTransmission(transmitOptions, buffer, bufferLen)                                                           \
4846         emberAfFillExternalBuffer(mask,                                                                                            \
4847                                                                                                                                    \
4848                                   ZCL_RECORD_TRANSMISSION_COMMAND_ID, "ub", transmitOptions, buffer, bufferLen);
4849
4850 /** @brief Command description for SearchGame
4851  *
4852  * Command: SearchGame
4853  * @param specificGame ENUM8
4854  * @param gameId INT16U
4855  * @param gameId INT16U
4856  * @param gameMaster BOOLEAN
4857  * @param listOfGame CHAR_STRING
4858  */
4859 #define emberAfFillCommandGamingClusterSearchGame(specificGame, gameId, gameId, gameMaster, listOfGame)                            \
4860     emberAfFillExternalBuffer(mask,                                                                                                \
4861                                                                                                                                    \
4862                               ZCL_SEARCH_GAME_COMMAND_ID, "uuuuu", specificGame, gameId, gameId, gameMaster, listOfGame);
4863
4864 /** @brief Command description for JoinGame
4865  *
4866  * Command: JoinGame
4867  * @param gameId INT16U
4868  * @param commandId INT8U
4869  * @param joinAsMaster BOOLEAN
4870  * @param status BITMAP8
4871  * @param nameOfGame CHAR_STRING
4872  * @param message CHAR_STRING
4873  */
4874 #define emberAfFillCommandGamingClusterJoinGame(gameId, commandId, joinAsMaster, status, nameOfGame, message)                      \
4875     emberAfFillExternalBuffer(mask,                                                                                                \
4876                                                                                                                                    \
4877                               ZCL_JOIN_GAME_COMMAND_ID, "uuuuuu", gameId, commandId, joinAsMaster, status, nameOfGame, message);
4878
4879 /** @brief Command description for StartGame
4880  *
4881  * Command: StartGame
4882  */
4883 #define emberAfFillCommandGamingClusterStartGame()                                                                                 \
4884     emberAfFillExternalBuffer(mask,                                                                                                \
4885                                                                                                                                    \
4886                               ZCL_START_GAME_COMMAND_ID, "", );
4887
4888 /** @brief Command description for PauseGame
4889  *
4890  * Command: PauseGame
4891  */
4892 #define emberAfFillCommandGamingClusterPauseGame()                                                                                 \
4893     emberAfFillExternalBuffer(mask,                                                                                                \
4894                                                                                                                                    \
4895                               ZCL_PAUSE_GAME_COMMAND_ID, "", );
4896
4897 /** @brief Command description for ResumeGame
4898  *
4899  * Command: ResumeGame
4900  */
4901 #define emberAfFillCommandGamingClusterResumeGame()                                                                                \
4902     emberAfFillExternalBuffer(mask,                                                                                                \
4903                                                                                                                                    \
4904                               ZCL_RESUME_GAME_COMMAND_ID, "", );
4905
4906 /** @brief Command description for QuitGame
4907  *
4908  * Command: QuitGame
4909  */
4910 #define emberAfFillCommandGamingClusterQuitGame()                                                                                  \
4911     emberAfFillExternalBuffer(mask,                                                                                                \
4912                                                                                                                                    \
4913                               ZCL_QUIT_GAME_COMMAND_ID, "", );
4914
4915 /** @brief Command description for EndGame
4916  *
4917  * Command: EndGame
4918  */
4919 #define emberAfFillCommandGamingClusterEndGame()                                                                                   \
4920     emberAfFillExternalBuffer(mask,                                                                                                \
4921                                                                                                                                    \
4922                               ZCL_END_GAME_COMMAND_ID, "", );
4923
4924 /** @brief Command description for StartOver
4925  *
4926  * Command: StartOver
4927  */
4928 #define emberAfFillCommandGamingClusterStartOver()                                                                                 \
4929     emberAfFillExternalBuffer(mask,                                                                                                \
4930                                                                                                                                    \
4931                               ZCL_START_OVER_COMMAND_ID, "", );
4932
4933 /** @brief Command description for ActionControl
4934  *
4935  * Command: ActionControl
4936  * @param actions BITMAP32
4937  */
4938 #define emberAfFillCommandGamingClusterActionControl(actions)                                                                      \
4939     emberAfFillExternalBuffer(mask,                                                                                                \
4940                                                                                                                                    \
4941                               ZCL_ACTION_CONTROL_COMMAND_ID, "u", actions);
4942
4943 /** @brief Command description for DownloadGame
4944  *
4945  * Command: DownloadGame
4946  */
4947 #define emberAfFillCommandGamingClusterDownloadGame()                                                                              \
4948     emberAfFillExternalBuffer(mask,                                                                                                \
4949                                                                                                                                    \
4950                               ZCL_DOWNLOAD_GAME_COMMAND_ID, "", );
4951
4952 /** @brief Command description for PathCreation
4953  *
4954  * Command: PathCreation
4955  * @param originatorAddress DATA16
4956  * @param originatorAddress DATA16
4957  * @param destinationAddress DATA16
4958  * @param destinationAddress DATA16
4959  * @param dataRate INT8U
4960  * @param dataRate INT8U
4961  */
4962 #define emberAfFillCommandData                                                                                                     \
4963     Rate ControlClusterPathCreation(originatorAddress, originatorAddress, destinationAddress, destinationAddress, dataRate,        \
4964                                     dataRate)                                                                                      \
4965         emberAfFillExternalBuffer(mask,                                                                                            \
4966                                                                                                                                    \
4967                                   ZCL_PATH_CREATION_COMMAND_ID, "uuuuuu", originatorAddress, originatorAddress,                    \
4968                                   destinationAddress, destinationAddress, dataRate, dataRate);
4969
4970 /** @brief Command description for DataRateNotification
4971  *
4972  * Command: DataRateNotification
4973  * @param originatorAddress DATA16
4974  * @param destinationAddress DATA16
4975  * @param dataRate INT8U
4976  */
4977 #define emberAfFillCommandData                                                                                                     \
4978     Rate ControlClusterDataRateNotification(originatorAddress, destinationAddress, dataRate)                                       \
4979         emberAfFillExternalBuffer(mask,                                                                                            \
4980                                                                                                                                    \
4981                                   ZCL_DATA_RATE_NOTIFICATION_COMMAND_ID, "uuu", originatorAddress, destinationAddress, dataRate);
4982
4983 /** @brief Command description for PathDeletion
4984  *
4985  * Command: PathDeletion
4986  * @param originatorAddress DATA16
4987  * @param destinationAddress DATA16
4988  */
4989 #define emberAfFillCommandData                                                                                                     \
4990     Rate ControlClusterPathDeletion(originatorAddress, destinationAddress)                                                         \
4991         emberAfFillExternalBuffer(mask,                                                                                            \
4992                                                                                                                                    \
4993                                   ZCL_PATH_DELETION_COMMAND_ID, "uu", originatorAddress, destinationAddress);
4994
4995 /** @brief Command description for EstablishmentRequest
4996  *
4997  * Command: EstablishmentRequest
4998  * @param flag BITMAP8
4999  * @param ackNack ENUM8
5000  * @param codecType ENUM8
5001  * @param codecType ENUM8
5002  * @param sampFreq ENUM8
5003  * @param codecRate ENUM8
5004  * @param serviceType ENUM8
5005  * @param buffer INT8U []
5006  * @param bufferLen int
5007  */
5008 #define emberAfFillCommandVoice                                                                                                    \
5009     over ZigBeeClusterEstablishmentRequest(flag, ackNack, codecType, codecType, sampFreq, codecRate, serviceType, buffer,          \
5010                                            bufferLen)                                                                              \
5011         emberAfFillExternalBuffer(mask,                                                                                            \
5012                                                                                                                                    \
5013                                   ZCL_ESTABLISHMENT_REQUEST_COMMAND_ID, "uuuuuuub", flag, ackNack, codecType, codecType, sampFreq, \
5014                                   codecRate, serviceType, buffer, bufferLen);
5015
5016 /** @brief Command description for VoiceTransmission
5017  *
5018  * Command: VoiceTransmission
5019  * @param voiceData INT8U []
5020  * @param voiceDataLen int
5021  * @param sequenceNumber INT8U
5022  * @param errorFlag ENUM8
5023  */
5024 #define emberAfFillCommandVoice                                                                                                    \
5025     over ZigBeeClusterVoiceTransmission(voiceData, voiceDataLen, sequenceNumber, errorFlag)                                        \
5026         emberAfFillExternalBuffer(mask,                                                                                            \
5027                                                                                                                                    \
5028                                   ZCL_VOICE_TRANSMISSION_COMMAND_ID, "buu", voiceData, voiceDataLen, sequenceNumber, errorFlag);
5029
5030 /** @brief Command description for VoiceTransmissionCompletion
5031  *
5032  * Command: VoiceTransmissionCompletion
5033  * @param controlType ENUM8
5034  */
5035 #define emberAfFillCommandVoice                                                                                                    \
5036     over ZigBeeClusterVoiceTransmissionCompletion(controlType)                                                                     \
5037         emberAfFillExternalBuffer(mask,                                                                                            \
5038                                                                                                                                    \
5039                                   ZCL_VOICE_TRANSMISSION_COMPLETION_COMMAND_ID, "u", controlType);
5040
5041 /** @brief Command description for ControlResponse
5042  *
5043  * Command: ControlResponse
5044  * @param ackNack ENUM8
5045  */
5046 #define emberAfFillCommandVoice                                                                                                    \
5047     over ZigBeeClusterControlResponse(ackNack) emberAfFillExternalBuffer(mask,                                                     \
5048                                                                                                                                    \
5049                                                                          ZCL_CONTROL_RESPONSE_COMMAND_ID, "u", ackNack);
5050
5051 /** @brief Command description for JoinChatRequest
5052  *
5053  * Command: JoinChatRequest
5054  * @param uid INT16U
5055  * @param status ENUM8
5056  * @param nickname CHAR_STRING
5057  * @param cid INT16U
5058  * @param cid INT16U
5059  */
5060 #define emberAfFillCommandChattingClusterJoinChatRequest(uid, status, nickname, cid, cid)                                          \
5061     emberAfFillExternalBuffer(mask,                                                                                                \
5062                                                                                                                                    \
5063                               ZCL_JOIN_CHAT_REQUEST_COMMAND_ID, "uuuuu", uid, status, nickname, cid, cid);
5064
5065 /** @brief Command description for LeaveChatRequest
5066  *
5067  * Command: LeaveChatRequest
5068  * @param cid INT16U
5069  * @param status ENUM8
5070  * @param uid INT16U
5071  * @param cid INT16U
5072  * @param chatParticipantList ChatParticipant []
5073  * @param chatParticipantListLen int
5074  */
5075 #define emberAfFillCommandChattingClusterLeaveChatRequest(cid, status, uid, cid, chatParticipantList, chatParticipantListLen)      \
5076     emberAfFillExternalBuffer(mask,                                                                                                \
5077                                                                                                                                    \
5078                               ZCL_LEAVE_CHAT_REQUEST_COMMAND_ID, "uuuub", cid, status, uid, cid, chatParticipantList,              \
5079                               chatParticipantListLen);
5080
5081 /** @brief Command description for SearchChatRequest
5082  *
5083  * Command: SearchChatRequest
5084  * @param cid INT16U
5085  * @param uid INT16U
5086  * @param nickname CHAR_STRING
5087  */
5088 #define emberAfFillCommandChattingClusterSearchChatRequest(cid, uid, nickname)                                                     \
5089     emberAfFillExternalBuffer(mask,                                                                                                \
5090                                                                                                                                    \
5091                               ZCL_SEARCH_CHAT_REQUEST_COMMAND_ID, "uuu", cid, uid, nickname);
5092
5093 /** @brief Command description for SwitchChairmanResponse
5094  *
5095  * Command: SwitchChairmanResponse
5096  * @param cid INT16U
5097  * @param cid INT16U
5098  * @param uid INT16U
5099  * @param uid INT16U
5100  * @param nickname CHAR_STRING
5101  */
5102 #define emberAfFillCommandChattingClusterSwitchChairmanResponse(cid, cid, uid, uid, nickname)                                      \
5103     emberAfFillExternalBuffer(mask,                                                                                                \
5104                                                                                                                                    \
5105                               ZCL_SWITCH_CHAIRMAN_RESPONSE_COMMAND_ID, "uuuuu", cid, cid, uid, uid, nickname);
5106
5107 /** @brief Command description for StartChatRequest
5108  *
5109  * Command: StartChatRequest
5110  * @param name CHAR_STRING
5111  * @param options BITMAP8
5112  * @param uid INT16U
5113  * @param chatRoomList ChatRoom []
5114  * @param chatRoomListLen int
5115  * @param nickname CHAR_STRING
5116  */
5117 #define emberAfFillCommandChattingClusterStartChatRequest(name, options, uid, chatRoomList, chatRoomListLen, nickname)             \
5118     emberAfFillExternalBuffer(mask,                                                                                                \
5119                                                                                                                                    \
5120                               ZCL_START_CHAT_REQUEST_COMMAND_ID, "uuubu", name, options, uid, chatRoomList, chatRoomListLen,       \
5121                               nickname);
5122
5123 /** @brief Command description for ChatMessage
5124  *
5125  * Command: ChatMessage
5126  * @param destinationUid INT16U
5127  * @param cid INT16U
5128  * @param sourceUid INT16U
5129  * @param cid INT16U
5130  * @param nickname CHAR_STRING
5131  * @param message CHAR_STRING
5132  */
5133 #define emberAfFillCommandChattingClusterChatMessage(destinationUid, cid, sourceUid, cid, nickname, message)                       \
5134     emberAfFillExternalBuffer(mask,                                                                                                \
5135                                                                                                                                    \
5136                               ZCL_CHAT_MESSAGE_COMMAND_ID, "uuuuuu", destinationUid, cid, sourceUid, cid, nickname, message);
5137
5138 /** @brief Command description for GetNodeInformationRequest
5139  *
5140  * Command: GetNodeInformationRequest
5141  * @param cid INT16U
5142  * @param cid INT16U
5143  * @param uid INT16U
5144  * @param nodeInformationList NodeInformation []
5145  * @param nodeInformationListLen int
5146  */
5147 #define emberAfFillCommandChattingClusterGetNodeInformationRequest(cid, cid, uid, nodeInformationList, nodeInformationListLen)     \
5148     emberAfFillExternalBuffer(mask,                                                                                                \
5149                                                                                                                                    \
5150                               ZCL_GET_NODE_INFORMATION_REQUEST_COMMAND_ID, "uuub", cid, cid, uid, nodeInformationList,             \
5151                               nodeInformationListLen);
5152
5153 /** @brief Command description for SwitchChairmanNotification
5154  *
5155  * Command: SwitchChairmanNotification
5156  * @param cid INT16U
5157  * @param uid INT16U
5158  * @param address DATA16
5159  * @param endpoint INT8U
5160  */
5161 #define emberAfFillCommandChattingClusterSwitchChairmanNotification(cid, uid, address, endpoint)                                   \
5162     emberAfFillExternalBuffer(mask,                                                                                                \
5163                                                                                                                                    \
5164                               ZCL_SWITCH_CHAIRMAN_NOTIFICATION_COMMAND_ID, "uuuu", cid, uid, address, endpoint);
5165
5166 /** @brief Command description for GetNodeInformationResponse
5167  *
5168  * Command: GetNodeInformationResponse
5169  * @param status ENUM8
5170  * @param cid INT16U
5171  * @param uid INT16U
5172  * @param addressEndpointAndNickname INT8U []
5173  * @param addressEndpointAndNicknameLen int
5174  */
5175 #define emberAfFillCommandChattingClusterGetNodeInformationResponse(status, cid, uid, addressEndpointAndNickname,                  \
5176                                                                     addressEndpointAndNicknameLen)                                 \
5177     emberAfFillExternalBuffer(mask,                                                                                                \
5178                                                                                                                                    \
5179                               ZCL_GET_NODE_INFORMATION_RESPONSE_COMMAND_ID, "uuub", status, cid, uid, addressEndpointAndNickname,  \
5180                               addressEndpointAndNicknameLen);
5181
5182 /** @brief Command description for BuyRequest
5183  *
5184  * Command: BuyRequest
5185  * @param userId OCTET_STRING
5186  * @param serialNumber OCTET_STRING
5187  * @param userType INT16U
5188  * @param currency INT32U
5189  * @param serviceId INT16U
5190  * @param priceTrailingDigit INT8U
5191  * @param goodId OCTET_STRING
5192  * @param price INT32U
5193  * @param timestamp OCTET_STRING
5194  * @param transId INT16U
5195  * @param transStatus ENUM8
5196  */
5197 #define emberAfFillCommandPaymentClusterBuyRequest(userId, serialNumber, userType, currency, serviceId, priceTrailingDigit,        \
5198                                                    goodId, price, timestamp, transId, transStatus)                                 \
5199     emberAfFillExternalBuffer(mask,                                                                                                \
5200                                                                                                                                    \
5201                               ZCL_BUY_REQUEST_COMMAND_ID, "uuuuuuuuuuu", userId, serialNumber, userType, currency, serviceId,      \
5202                               priceTrailingDigit, goodId, price, timestamp, transId, transStatus);
5203
5204 /** @brief Command description for AcceptPayment
5205  *
5206  * Command: AcceptPayment
5207  * @param userId OCTET_STRING
5208  * @param serialNumber OCTET_STRING
5209  * @param userType INT16U
5210  * @param currency INT32U
5211  * @param serviceId INT16U
5212  * @param priceTrailingDigit INT8U
5213  * @param goodId OCTET_STRING
5214  * @param price INT32U
5215  * @param timestamp OCTET_STRING
5216  */
5217 #define emberAfFillCommandPaymentClusterAcceptPayment(userId, serialNumber, userType, currency, serviceId, priceTrailingDigit,     \
5218                                                       goodId, price, timestamp)                                                    \
5219     emberAfFillExternalBuffer(mask,                                                                                                \
5220                                                                                                                                    \
5221                               ZCL_ACCEPT_PAYMENT_COMMAND_ID, "uuuuuuuuu", userId, serialNumber, userType, currency, serviceId,     \
5222                               priceTrailingDigit, goodId, price, timestamp);
5223
5224 /** @brief Command description for PaymentConfirm
5225  *
5226  * Command: PaymentConfirm
5227  * @param serialNumber OCTET_STRING
5228  * @param serialNumber OCTET_STRING
5229  * @param transId INT16U
5230  * @param status ENUM8
5231  * @param transStatus ENUM8
5232  */
5233 #define emberAfFillCommandPaymentClusterPaymentConfirm(serialNumber, serialNumber, transId, status, transStatus)                   \
5234     emberAfFillExternalBuffer(mask,                                                                                                \
5235                                                                                                                                    \
5236                               ZCL_PAYMENT_CONFIRM_COMMAND_ID, "uuuuu", serialNumber, serialNumber, transId, status, transStatus);
5237
5238 /** @brief Command description for Subscribe
5239  *
5240  * Command: Subscribe
5241  * @param userId OCTET_STRING
5242  * @param userId OCTET_STRING
5243  * @param serviceId INT16U
5244  * @param serviceId INT16U
5245  * @param serviceProviderId INT16U
5246  * @param serviceProviderId INT16U
5247  */
5248 #define emberAfFillCommandBillingClusterSubscribe(userId, userId, serviceId, serviceId, serviceProviderId, serviceProviderId)      \
5249     emberAfFillExternalBuffer(mask,                                                                                                \
5250                                                                                                                                    \
5251                               ZCL_SUBSCRIBE_COMMAND_ID, "uuuuuu", userId, userId, serviceId, serviceId, serviceProviderId,         \
5252                               serviceProviderId);
5253
5254 /** @brief Command description for Unsubscribe
5255  *
5256  * Command: Unsubscribe
5257  * @param userId OCTET_STRING
5258  * @param userId OCTET_STRING
5259  * @param serviceId INT16U
5260  * @param serviceId INT16U
5261  * @param serviceProviderId INT16U
5262  * @param serviceProviderId INT16U
5263  * @param timestamp OCTET_STRING
5264  * @param duration INT16U
5265  */
5266 #define emberAfFillCommandBillingClusterUnsubscribe(userId, userId, serviceId, serviceId, serviceProviderId, serviceProviderId,    \
5267                                                     timestamp, duration)                                                           \
5268     emberAfFillExternalBuffer(mask,                                                                                                \
5269                                                                                                                                    \
5270                               ZCL_UNSUBSCRIBE_COMMAND_ID, "uuuuuuuu", userId, userId, serviceId, serviceId, serviceProviderId,     \
5271                               serviceProviderId, timestamp, duration);
5272
5273 /** @brief Command description for StartBillingSession
5274  *
5275  * Command: StartBillingSession
5276  * @param userId OCTET_STRING
5277  * @param serviceId INT16U
5278  * @param serviceProviderId INT16U
5279  */
5280 #define emberAfFillCommandBillingClusterStartBillingSession(userId, serviceId, serviceProviderId)                                  \
5281     emberAfFillExternalBuffer(mask,                                                                                                \
5282                                                                                                                                    \
5283                               ZCL_START_BILLING_SESSION_COMMAND_ID, "uuu", userId, serviceId, serviceProviderId);
5284
5285 /** @brief Command description for StopBillingSession
5286  *
5287  * Command: StopBillingSession
5288  * @param userId OCTET_STRING
5289  * @param serviceId INT16U
5290  * @param serviceProviderId INT16U
5291  */
5292 #define emberAfFillCommandBillingClusterStopBillingSession(userId, serviceId, serviceProviderId)                                   \
5293     emberAfFillExternalBuffer(mask,                                                                                                \
5294                                                                                                                                    \
5295                               ZCL_STOP_BILLING_SESSION_COMMAND_ID, "uuu", userId, serviceId, serviceProviderId);
5296
5297 /** @brief Command description for BillStatusNotification
5298  *
5299  * Command: BillStatusNotification
5300  * @param userId OCTET_STRING
5301  * @param status ENUM8
5302  */
5303 #define emberAfFillCommandBillingClusterBillStatusNotification(userId, status)                                                     \
5304     emberAfFillExternalBuffer(mask,                                                                                                \
5305                                                                                                                                    \
5306                               ZCL_BILL_STATUS_NOTIFICATION_COMMAND_ID, "uu", userId, status);
5307
5308 /** @brief Command description for SessionKeepAlive
5309  *
5310  * Command: SessionKeepAlive
5311  * @param userId OCTET_STRING
5312  * @param serviceId INT16U
5313  * @param serviceProviderId INT16U
5314  */
5315 #define emberAfFillCommandBillingClusterSessionKeepAlive(userId, serviceId, serviceProviderId)                                     \
5316     emberAfFillExternalBuffer(mask,                                                                                                \
5317                                                                                                                                    \
5318                               ZCL_SESSION_KEEP_ALIVE_COMMAND_ID, "uuu", userId, serviceId, serviceProviderId);
5319
5320 /** @brief Command description for GetAlerts
5321  *
5322  * Command: GetAlerts
5323  * @param alertsCount AlertCount
5324  * @param alertStructures AlertStructure []
5325  * @param alertStructuresLen int
5326  */
5327 #define emberAfFillCommandAppliance                                                                                                \
5328     Events and AlertClusterGetAlerts(alertsCount, alertStructures, alertStructuresLen)                                             \
5329         emberAfFillExternalBuffer(mask,                                                                                            \
5330                                                                                                                                    \
5331                                   ZCL_GET_ALERTS_COMMAND_ID, "ub", alertsCount, alertStructures, alertStructuresLen);
5332
5333 /** @brief Command description for AlertsNotification
5334  *
5335  * Command: AlertsNotification
5336  * @param alertsCount AlertCount
5337  * @param alertStructures AlertStructure []
5338  * @param alertStructuresLen int
5339  */
5340 #define emberAfFillCommandAppliance                                                                                                \
5341     Events and AlertClusterAlertsNotification(alertsCount, alertStructures, alertStructuresLen)                                    \
5342         emberAfFillExternalBuffer(mask,                                                                                            \
5343                                                                                                                                    \
5344                                   ZCL_ALERTS_NOTIFICATION_COMMAND_ID, "ub", alertsCount, alertStructures, alertStructuresLen);
5345
5346 /** @brief Command description for EventsNotification
5347  *
5348  * Command: EventsNotification
5349  * @param eventHeader INT8U
5350  * @param eventId EventIdentification
5351  */
5352 #define emberAfFillCommandAppliance                                                                                                \
5353     Events and AlertClusterEventsNotification(eventHeader, eventId)                                                                \
5354         emberAfFillExternalBuffer(mask,                                                                                            \
5355                                                                                                                                    \
5356                                   ZCL_EVENTS_NOTIFICATION_COMMAND_ID, "uu", eventHeader, eventId);
5357
5358 /** @brief Command description for LogNotification
5359  *
5360  * Command: LogNotification
5361  * @param timeStamp TIME_OF_DAY
5362  * @param logId INT32U
5363  * @param logId INT32U
5364  * @param logLength INT32U
5365  * @param logPayload INT8U []
5366  * @param logPayloadLen int
5367  */
5368 #define emberAfFillCommandAppliance                                                                                                \
5369     StatisticsClusterLogNotification(timeStamp, logId, logId, logLength, logPayload, logPayloadLen) emberAfFillExternalBuffer(     \
5370         mask,                                                                                                                      \
5371                                                                                                                                    \
5372         ZCL_LOG_NOTIFICATION_COMMAND_ID, "uuuub", timeStamp, logId, logId, logLength, logPayload, logPayloadLen);
5373
5374 /** @brief Command description for LogQueueRequest
5375  *
5376  * Command: LogQueueRequest
5377  * @param timeStamp TIME_OF_DAY
5378  * @param logId INT32U
5379  * @param logLength INT32U
5380  * @param logPayload INT8U []
5381  * @param logPayloadLen int
5382  */
5383 #define emberAfFillCommandAppliance                                                                                                \
5384     StatisticsClusterLogQueueRequest(timeStamp, logId, logLength, logPayload, logPayloadLen) emberAfFillExternalBuffer(            \
5385         mask,                                                                                                                      \
5386                                                                                                                                    \
5387         ZCL_LOG_QUEUE_REQUEST_COMMAND_ID, "uuub", timeStamp, logId, logLength, logPayload, logPayloadLen);
5388
5389 /** @brief Command description for LogQueueResponse
5390  *
5391  * Command: LogQueueResponse
5392  * @param logQueueSize INT8U
5393  * @param logIds INT32U []
5394  * @param logIdsLen int
5395  */
5396 #define emberAfFillCommandAppliance                                                                                                \
5397     StatisticsClusterLogQueueResponse(logQueueSize, logIds, logIdsLen)                                                             \
5398         emberAfFillExternalBuffer(mask,                                                                                            \
5399                                                                                                                                    \
5400                                   ZCL_LOG_QUEUE_RESPONSE_COMMAND_ID, "ub", logQueueSize, logIds, logIdsLen);
5401
5402 /** @brief Command description for StatisticsAvailable
5403  *
5404  * Command: StatisticsAvailable
5405  * @param logQueueSize INT8U
5406  * @param logIds INT32U []
5407  * @param logIdsLen int
5408  */
5409 #define emberAfFillCommandAppliance                                                                                                \
5410     StatisticsClusterStatisticsAvailable(logQueueSize, logIds, logIdsLen)                                                          \
5411         emberAfFillExternalBuffer(mask,                                                                                            \
5412                                                                                                                                    \
5413                                   ZCL_STATISTICS_AVAILABLE_COMMAND_ID, "ub", logQueueSize, logIds, logIdsLen);
5414
5415 /** @brief Command description for GetProfileInfoCommand
5416  *
5417  * Command: GetProfileInfoCommand
5418  * @param profileCount INT8U
5419  * @param profileIntervalPeriod ENUM8
5420  * @param maxNumberOfIntervals INT8U
5421  * @param listOfAttributes INT16U []
5422  * @param listOfAttributesLen int
5423  */
5424 #define emberAfFillCommandElectrical                                                                                               \
5425     MeasurementClusterGetProfileInfoCommand(profileCount, profileIntervalPeriod, maxNumberOfIntervals, listOfAttributes,           \
5426                                             listOfAttributesLen)                                                                   \
5427         emberAfFillExternalBuffer(mask,                                                                                            \
5428                                                                                                                                    \
5429                                   ZCL_GET_PROFILE_INFO_COMMAND_COMMAND_ID, "uuub", profileCount, profileIntervalPeriod,            \
5430                                   maxNumberOfIntervals, listOfAttributes, listOfAttributesLen);
5431
5432 /** @brief Command description for GetMeasurementProfileResponseCommand
5433  *
5434  * Command: GetMeasurementProfileResponseCommand
5435  * @param startTime INT32U
5436  * @param attributeId INT16U
5437  * @param status ENUM8
5438  * @param startTime INT32U
5439  * @param profileIntervalPeriod ENUM8
5440  * @param numberOfIntervals ENUM8
5441  * @param numberOfIntervalsDelivered INT8U
5442  * @param attributeId INT16U
5443  * @param intervals INT8U []
5444  * @param intervalsLen int
5445  */
5446 #define emberAfFillCommandElectrical                                                                                               \
5447     MeasurementClusterGetMeasurementProfileResponseCommand(startTime, attributeId, status, startTime, profileIntervalPeriod,       \
5448                                                            numberOfIntervals, numberOfIntervalsDelivered, attributeId, intervals,  \
5449                                                            intervalsLen)                                                           \
5450         emberAfFillExternalBuffer(mask,                                                                                            \
5451                                                                                                                                    \
5452                                   ZCL_GET_MEASUREMENT_PROFILE_RESPONSE_COMMAND_COMMAND_ID, "uuuuuuuub", startTime, attributeId,    \
5453                                   status, startTime, profileIntervalPeriod, numberOfIntervals, numberOfIntervalsDelivered,         \
5454                                   attributeId, intervals, intervalsLen);
5455
5456 /** @brief Command description for ScanRequest
5457  *
5458  * Command: ScanRequest
5459  * @param transaction INT32U
5460  * @param zigbeeInformation ZigbeeInformation
5461  * @param zllInformation ZllInformation
5462  */
5463 #define emberAfFillCommandZLL                                                                                                      \
5464     CommissioningClusterScanRequest(transaction, zigbeeInformation, zllInformation)                                                \
5465         emberAfFillExternalBuffer(mask,                                                                                            \
5466                                                                                                                                    \
5467                                   ZCL_SCAN_REQUEST_COMMAND_ID, "uuu", transaction, zigbeeInformation, zllInformation);
5468
5469 /** @brief Command description for ScanResponse
5470  *
5471  * Command: ScanResponse
5472  * @param transaction INT32U
5473  * @param rssiCorrection INT8U
5474  * @param zigbeeInformation ZigbeeInformation
5475  * @param zllInformation ZllInformation
5476  * @param keyBitmask KeyBitmask
5477  * @param responseId INT32U
5478  * @param extendedPanId IEEE_ADDRESS
5479  * @param networkUpdateId INT8U
5480  * @param logicalChannel INT8U
5481  * @param panId INT16U
5482  * @param networkAddress INT16U
5483  * @param numberOfSubDevices INT8U
5484  * @param totalGroupIds INT8U
5485  * @param endpointId INT8U
5486  * @param profileId INT16U
5487  * @param deviceId INT16U
5488  * @param version INT8U
5489  * @param groupIdCount INT8U
5490  */
5491 #define emberAfFillCommandZLL                                                                                                      \
5492     CommissioningClusterScanResponse(transaction, rssiCorrection, zigbeeInformation, zllInformation, keyBitmask, responseId,       \
5493                                      extendedPanId, networkUpdateId, logicalChannel, panId, networkAddress, numberOfSubDevices,    \
5494                                      totalGroupIds, endpointId, profileId, deviceId, version, groupIdCount)                        \
5495         emberAfFillExternalBuffer(mask,                                                                                            \
5496                                                                                                                                    \
5497                                   ZCL_SCAN_RESPONSE_COMMAND_ID, "uuuuuuuuuuuuuuuuuu", transaction, rssiCorrection,                 \
5498                                   zigbeeInformation, zllInformation, keyBitmask, responseId, extendedPanId, networkUpdateId,       \
5499                                   logicalChannel, panId, networkAddress, numberOfSubDevices, totalGroupIds, endpointId, profileId, \
5500                                   deviceId, version, groupIdCount);
5501
5502 /** @brief Command description for DeviceInformationRequest
5503  *
5504  * Command: DeviceInformationRequest
5505  * @param transaction INT32U
5506  * @param startIndex INT8U
5507  */
5508 #define emberAfFillCommandZLL                                                                                                      \
5509     CommissioningClusterDeviceInformationRequest(transaction, startIndex)                                                          \
5510         emberAfFillExternalBuffer(mask,                                                                                            \
5511                                                                                                                                    \
5512                                   ZCL_DEVICE_INFORMATION_REQUEST_COMMAND_ID, "uu", transaction, startIndex);
5513
5514 /** @brief Command description for DeviceInformationResponse
5515  *
5516  * Command: DeviceInformationResponse
5517  * @param transaction INT32U
5518  * @param numberOfSubDevices INT8U
5519  * @param startIndex INT8U
5520  * @param deviceInformationRecordCount INT8U
5521  * @param deviceInformationRecordList DeviceInformationRecord []
5522  * @param deviceInformationRecordListLen int
5523  */
5524 #define emberAfFillCommandZLL                                                                                                      \
5525     CommissioningClusterDeviceInformationResponse(transaction, numberOfSubDevices, startIndex, deviceInformationRecordCount,       \
5526                                                   deviceInformationRecordList, deviceInformationRecordListLen)                     \
5527         emberAfFillExternalBuffer(mask,                                                                                            \
5528                                                                                                                                    \
5529                                   ZCL_DEVICE_INFORMATION_RESPONSE_COMMAND_ID, "uuuub", transaction, numberOfSubDevices,            \
5530                                   startIndex, deviceInformationRecordCount, deviceInformationRecordList,                           \
5531                                   deviceInformationRecordListLen);
5532
5533 /** @brief Command description for IdentifyRequest
5534  *
5535  * Command: IdentifyRequest
5536  * @param transaction INT32U
5537  * @param identifyDuration INT16U
5538  */
5539 #define emberAfFillCommandZLL                                                                                                      \
5540     CommissioningClusterIdentifyRequest(transaction, identifyDuration)                                                             \
5541         emberAfFillExternalBuffer(mask,                                                                                            \
5542                                                                                                                                    \
5543                                   ZCL_IDENTIFY_REQUEST_COMMAND_ID, "uu", transaction, identifyDuration);
5544
5545 /** @brief Command description for ResetToFactoryNewRequest
5546  *
5547  * Command: ResetToFactoryNewRequest
5548  * @param transaction INT32U
5549  */
5550 #define emberAfFillCommandZLL                                                                                                      \
5551     CommissioningClusterResetToFactoryNewRequest(transaction)                                                                      \
5552         emberAfFillExternalBuffer(mask,                                                                                            \
5553                                                                                                                                    \
5554                                   ZCL_RESET_TO_FACTORY_NEW_REQUEST_COMMAND_ID, "u", transaction);
5555
5556 /** @brief Command description for NetworkStartRequest
5557  *
5558  * Command: NetworkStartRequest
5559  * @param transaction INT32U
5560  * @param extendedPanId IEEE_ADDRESS
5561  * @param keyIndex KeyIndex
5562  * @param encryptedNetworkKey SECURITY_KEY
5563  * @param logicalChannel INT8U
5564  * @param panId INT16U
5565  * @param networkAddress INT16U
5566  * @param groupIdentifiersBegin INT16U
5567  * @param groupIdentifiersEnd INT16U
5568  * @param freeNetworkAddressRangeBegin INT16U
5569  * @param freeNetworkAddressRangeEnd INT16U
5570  * @param freeGroupIdentifierRangeBegin INT16U
5571  * @param freeGroupIdentifierRangeEnd INT16U
5572  * @param initiatorIeeeAddress IEEE_ADDRESS
5573  * @param initiatorNetworkAddress INT16U
5574  */
5575 #define emberAfFillCommandZLL                                                                                                      \
5576     CommissioningClusterNetworkStartRequest(                                                                                       \
5577         transaction, extendedPanId, keyIndex, encryptedNetworkKey, logicalChannel, panId, networkAddress, groupIdentifiersBegin,   \
5578         groupIdentifiersEnd, freeNetworkAddressRangeBegin, freeNetworkAddressRangeEnd, freeGroupIdentifierRangeBegin,              \
5579         freeGroupIdentifierRangeEnd, initiatorIeeeAddress, initiatorNetworkAddress)                                                \
5580         emberAfFillExternalBuffer(mask,                                                                                            \
5581                                                                                                                                    \
5582                                   ZCL_NETWORK_START_REQUEST_COMMAND_ID, "uuuuuuuuuuuuuuu", transaction, extendedPanId, keyIndex,   \
5583                                   encryptedNetworkKey, logicalChannel, panId, networkAddress, groupIdentifiersBegin,               \
5584                                   groupIdentifiersEnd, freeNetworkAddressRangeBegin, freeNetworkAddressRangeEnd,                   \
5585                                   freeGroupIdentifierRangeBegin, freeGroupIdentifierRangeEnd, initiatorIeeeAddress,                \
5586                                   initiatorNetworkAddress);
5587
5588 /** @brief Command description for NetworkStartResponse
5589  *
5590  * Command: NetworkStartResponse
5591  * @param transaction INT32U
5592  * @param status ZllStatus
5593  * @param extendedPanId IEEE_ADDRESS
5594  * @param networkUpdateId INT8U
5595  * @param logicalChannel INT8U
5596  * @param panId INT16U
5597  */
5598 #define emberAfFillCommandZLL                                                                                                      \
5599     CommissioningClusterNetworkStartResponse(transaction, status, extendedPanId, networkUpdateId, logicalChannel, panId)           \
5600         emberAfFillExternalBuffer(mask,                                                                                            \
5601                                                                                                                                    \
5602                                   ZCL_NETWORK_START_RESPONSE_COMMAND_ID, "uuuuuu", transaction, status, extendedPanId,             \
5603                                   networkUpdateId, logicalChannel, panId);
5604
5605 /** @brief Command description for NetworkJoinRouterRequest
5606  *
5607  * Command: NetworkJoinRouterRequest
5608  * @param transaction INT32U
5609  * @param extendedPanId IEEE_ADDRESS
5610  * @param keyIndex KeyIndex
5611  * @param encryptedNetworkKey SECURITY_KEY
5612  * @param networkUpdateId INT8U
5613  * @param logicalChannel INT8U
5614  * @param panId INT16U
5615  * @param networkAddress INT16U
5616  * @param groupIdentifiersBegin INT16U
5617  * @param groupIdentifiersEnd INT16U
5618  * @param freeNetworkAddressRangeBegin INT16U
5619  * @param freeNetworkAddressRangeEnd INT16U
5620  * @param freeGroupIdentifierRangeBegin INT16U
5621  * @param freeGroupIdentifierRangeEnd INT16U
5622  */
5623 #define emberAfFillCommandZLL                                                                                                      \
5624     CommissioningClusterNetworkJoinRouterRequest(transaction, extendedPanId, keyIndex, encryptedNetworkKey, networkUpdateId,       \
5625                                                  logicalChannel, panId, networkAddress, groupIdentifiersBegin,                     \
5626                                                  groupIdentifiersEnd, freeNetworkAddressRangeBegin, freeNetworkAddressRangeEnd,    \
5627                                                  freeGroupIdentifierRangeBegin, freeGroupIdentifierRangeEnd)                       \
5628         emberAfFillExternalBuffer(mask,                                                                                            \
5629                                                                                                                                    \
5630                                   ZCL_NETWORK_JOIN_ROUTER_REQUEST_COMMAND_ID, "uuuuuuuuuuuuuu", transaction, extendedPanId,        \
5631                                   keyIndex, encryptedNetworkKey, networkUpdateId, logicalChannel, panId, networkAddress,           \
5632                                   groupIdentifiersBegin, groupIdentifiersEnd, freeNetworkAddressRangeBegin,                        \
5633                                   freeNetworkAddressRangeEnd, freeGroupIdentifierRangeBegin, freeGroupIdentifierRangeEnd);
5634
5635 /** @brief Command description for NetworkJoinRouterResponse
5636  *
5637  * Command: NetworkJoinRouterResponse
5638  * @param transaction INT32U
5639  * @param status ZllStatus
5640  */
5641 #define emberAfFillCommandZLL                                                                                                      \
5642     CommissioningClusterNetworkJoinRouterResponse(transaction, status)                                                             \
5643         emberAfFillExternalBuffer(mask,                                                                                            \
5644                                                                                                                                    \
5645                                   ZCL_NETWORK_JOIN_ROUTER_RESPONSE_COMMAND_ID, "uu", transaction, status);
5646
5647 /** @brief Command description for NetworkJoinEndDeviceRequest
5648  *
5649  * Command: NetworkJoinEndDeviceRequest
5650  * @param transaction INT32U
5651  * @param extendedPanId IEEE_ADDRESS
5652  * @param keyIndex KeyIndex
5653  * @param encryptedNetworkKey SECURITY_KEY
5654  * @param networkUpdateId INT8U
5655  * @param logicalChannel INT8U
5656  * @param panId INT16U
5657  * @param networkAddress INT16U
5658  * @param groupIdentifiersBegin INT16U
5659  * @param groupIdentifiersEnd INT16U
5660  * @param freeNetworkAddressRangeBegin INT16U
5661  * @param freeNetworkAddressRangeEnd INT16U
5662  * @param freeGroupIdentifierRangeBegin INT16U
5663  * @param freeGroupIdentifierRangeEnd INT16U
5664  */
5665 #define emberAfFillCommandZLL                                                                                                      \
5666     CommissioningClusterNetworkJoinEndDeviceRequest(transaction, extendedPanId, keyIndex, encryptedNetworkKey, networkUpdateId,    \
5667                                                     logicalChannel, panId, networkAddress, groupIdentifiersBegin,                  \
5668                                                     groupIdentifiersEnd, freeNetworkAddressRangeBegin, freeNetworkAddressRangeEnd, \
5669                                                     freeGroupIdentifierRangeBegin, freeGroupIdentifierRangeEnd)                    \
5670         emberAfFillExternalBuffer(mask,                                                                                            \
5671                                                                                                                                    \
5672                                   ZCL_NETWORK_JOIN_END_DEVICE_REQUEST_COMMAND_ID, "uuuuuuuuuuuuuu", transaction, extendedPanId,    \
5673                                   keyIndex, encryptedNetworkKey, networkUpdateId, logicalChannel, panId, networkAddress,           \
5674                                   groupIdentifiersBegin, groupIdentifiersEnd, freeNetworkAddressRangeBegin,                        \
5675                                   freeNetworkAddressRangeEnd, freeGroupIdentifierRangeBegin, freeGroupIdentifierRangeEnd);
5676
5677 /** @brief Command description for NetworkJoinEndDeviceResponse
5678  *
5679  * Command: NetworkJoinEndDeviceResponse
5680  * @param transaction INT32U
5681  * @param status ZllStatus
5682  */
5683 #define emberAfFillCommandZLL                                                                                                      \
5684     CommissioningClusterNetworkJoinEndDeviceResponse(transaction, status)                                                          \
5685         emberAfFillExternalBuffer(mask,                                                                                            \
5686                                                                                                                                    \
5687                                   ZCL_NETWORK_JOIN_END_DEVICE_RESPONSE_COMMAND_ID, "uu", transaction, status);
5688
5689 /** @brief Command description for NetworkUpdateRequest
5690  *
5691  * Command: NetworkUpdateRequest
5692  * @param transaction INT32U
5693  * @param extendedPanId IEEE_ADDRESS
5694  * @param networkUpdateId INT8U
5695  * @param logicalChannel INT8U
5696  * @param panId INT16U
5697  * @param networkAddress INT16U
5698  */
5699 #define emberAfFillCommandZLL                                                                                                      \
5700     CommissioningClusterNetworkUpdateRequest(transaction, extendedPanId, networkUpdateId, logicalChannel, panId, networkAddress)   \
5701         emberAfFillExternalBuffer(mask,                                                                                            \
5702                                                                                                                                    \
5703                                   ZCL_NETWORK_UPDATE_REQUEST_COMMAND_ID, "uuuuuu", transaction, extendedPanId, networkUpdateId,    \
5704                                   logicalChannel, panId, networkAddress);
5705
5706 /** @brief Command description for EndpointInformation
5707  *
5708  * Command: EndpointInformation
5709  * @param ieeeAddress IEEE_ADDRESS
5710  * @param networkAddress INT16U
5711  * @param endpointId INT8U
5712  * @param profileId INT16U
5713  * @param deviceId INT16U
5714  * @param version INT8U
5715  */
5716 #define emberAfFillCommandZLL                                                                                                      \
5717     CommissioningClusterEndpointInformation(ieeeAddress, networkAddress, endpointId, profileId, deviceId, version)                 \
5718         emberAfFillExternalBuffer(mask,                                                                                            \
5719                                                                                                                                    \
5720                                   ZCL_ENDPOINT_INFORMATION_COMMAND_ID, "uuuuuu", ieeeAddress, networkAddress, endpointId,          \
5721                                   profileId, deviceId, version);
5722
5723 /** @brief Command description for GetGroupIdentifiersRequest
5724  *
5725  * Command: GetGroupIdentifiersRequest
5726  * @param startIndex INT8U
5727  * @param total INT8U
5728  * @param startIndex INT8U
5729  * @param count INT8U
5730  * @param groupInformationRecordList GroupInformationRecord []
5731  * @param groupInformationRecordListLen int
5732  */
5733 #define emberAfFillCommandZLL                                                                                                      \
5734     CommissioningClusterGetGroupIdentifiersRequest(startIndex, total, startIndex, count, groupInformationRecordList,               \
5735                                                    groupInformationRecordListLen)                                                  \
5736         emberAfFillExternalBuffer(mask,                                                                                            \
5737                                                                                                                                    \
5738                                   ZCL_GET_GROUP_IDENTIFIERS_REQUEST_COMMAND_ID, "uuuub", startIndex, total, startIndex, count,     \
5739                                   groupInformationRecordList, groupInformationRecordListLen);
5740
5741 /** @brief Command description for GetEndpointListRequest
5742  *
5743  * Command: GetEndpointListRequest
5744  * @param startIndex INT8U
5745  * @param total INT8U
5746  * @param startIndex INT8U
5747  * @param count INT8U
5748  * @param endpointInformationRecordList EndpointInformationRecord []
5749  * @param endpointInformationRecordListLen int
5750  */
5751 #define emberAfFillCommandZLL                                                                                                      \
5752     CommissioningClusterGetEndpointListRequest(startIndex, total, startIndex, count, endpointInformationRecordList,                \
5753                                                endpointInformationRecordListLen)                                                   \
5754         emberAfFillExternalBuffer(mask,                                                                                            \
5755                                                                                                                                    \
5756                                   ZCL_GET_ENDPOINT_LIST_REQUEST_COMMAND_ID, "uuuub", startIndex, total, startIndex, count,         \
5757                                   endpointInformationRecordList, endpointInformationRecordListLen);
5758
5759 /** @brief Command description for ScanNetworks
5760  *
5761  * Command: ScanNetworks
5762  * @param ssid OCTET_STRING
5763  * @param breadcrumb INT64U
5764  * @param timeoutMs INT32U
5765  */
5766 #define emberAfFillCommandNetwork                                                                                                  \
5767     CommissioningClusterScanNetworks(ssid, breadcrumb, timeoutMs)                                                                  \
5768         emberAfFillExternalBuffer(mask,                                                                                            \
5769                                                                                                                                    \
5770                                   ZCL_SCAN_NETWORKS_COMMAND_ID, "uuu", ssid, breadcrumb, timeoutMs);
5771
5772 /** @brief Command description for ScanNetworksResponse
5773  *
5774  * Command: ScanNetworksResponse
5775  * @param errorCode INT8U
5776  * @param debugText CHAR_STRING
5777  * @param wifiScanResults WiFiInterfaceScanResult []
5778  * @param wifiScanResultsLen int
5779  * @param threadScanResults ThreadInterfaceScanResult []
5780  * @param threadScanResultsLen int
5781  */
5782 #define emberAfFillCommandNetwork                                                                                                  \
5783     CommissioningClusterScanNetworksResponse(errorCode, debugText, wifiScanResults, wifiScanResultsLen, threadScanResults,         \
5784                                              threadScanResultsLen)                                                                 \
5785         emberAfFillExternalBuffer(mask,                                                                                            \
5786                                                                                                                                    \
5787                                   ZCL_SCAN_NETWORKS_RESPONSE_COMMAND_ID, "uubb", errorCode, debugText, wifiScanResults,            \
5788                                   wifiScanResultsLen, threadScanResults, threadScanResultsLen);
5789
5790 /** @brief Command description for AddWiFiNetwork
5791  *
5792  * Command: AddWiFiNetwork
5793  * @param ssid OCTET_STRING
5794  * @param credentials OCTET_STRING
5795  * @param breadcrumb INT64U
5796  * @param timeoutMs INT32U
5797  */
5798 #define emberAfFillCommandNetwork                                                                                                  \
5799     CommissioningClusterAddWiFiNetwork(ssid, credentials, breadcrumb, timeoutMs)                                                   \
5800         emberAfFillExternalBuffer(mask,                                                                                            \
5801                                                                                                                                    \
5802                                   ZCL_ADD_WI_FI_NETWORK_COMMAND_ID, "uuuu", ssid, credentials, breadcrumb, timeoutMs);
5803
5804 /** @brief Command description for AddWiFiNetworkResponse
5805  *
5806  * Command: AddWiFiNetworkResponse
5807  * @param errorCode INT8U
5808  * @param debugText CHAR_STRING
5809  */
5810 #define emberAfFillCommandNetwork                                                                                                  \
5811     CommissioningClusterAddWiFiNetworkResponse(errorCode, debugText)                                                               \
5812         emberAfFillExternalBuffer(mask,                                                                                            \
5813                                                                                                                                    \
5814                                   ZCL_ADD_WI_FI_NETWORK_RESPONSE_COMMAND_ID, "uu", errorCode, debugText);
5815
5816 /** @brief Command description for UpdateWiFiNetwork
5817  *
5818  * Command: UpdateWiFiNetwork
5819  * @param ssid OCTET_STRING
5820  * @param credentials OCTET_STRING
5821  * @param breadcrumb INT64U
5822  * @param timeoutMs INT32U
5823  */
5824 #define emberAfFillCommandNetwork                                                                                                  \
5825     CommissioningClusterUpdateWiFiNetwork(ssid, credentials, breadcrumb, timeoutMs)                                                \
5826         emberAfFillExternalBuffer(mask,                                                                                            \
5827                                                                                                                                    \
5828                                   ZCL_UPDATE_WI_FI_NETWORK_COMMAND_ID, "uuuu", ssid, credentials, breadcrumb, timeoutMs);
5829
5830 /** @brief Command description for UpdateWiFiNetworkResponse
5831  *
5832  * Command: UpdateWiFiNetworkResponse
5833  * @param errorCode INT8U
5834  * @param debugText CHAR_STRING
5835  */
5836 #define emberAfFillCommandNetwork                                                                                                  \
5837     CommissioningClusterUpdateWiFiNetworkResponse(errorCode, debugText)                                                            \
5838         emberAfFillExternalBuffer(mask,                                                                                            \
5839                                                                                                                                    \
5840                                   ZCL_UPDATE_WI_FI_NETWORK_RESPONSE_COMMAND_ID, "uu", errorCode, debugText);
5841
5842 /** @brief Command description for AddThreadNetwork
5843  *
5844  * Command: AddThreadNetwork
5845  * @param operationalDataset OCTET_STRING
5846  * @param breadcrumb INT64U
5847  * @param timeoutMs INT32U
5848  */
5849 #define emberAfFillCommandNetwork                                                                                                  \
5850     CommissioningClusterAddThreadNetwork(operationalDataset, breadcrumb, timeoutMs)                                                \
5851         emberAfFillExternalBuffer(mask,                                                                                            \
5852                                                                                                                                    \
5853                                   ZCL_ADD_THREAD_NETWORK_COMMAND_ID, "uuu", operationalDataset, breadcrumb, timeoutMs);
5854
5855 /** @brief Command description for AddThreadNetworkResponse
5856  *
5857  * Command: AddThreadNetworkResponse
5858  * @param errorCode INT8U
5859  * @param debugText CHAR_STRING
5860  */
5861 #define emberAfFillCommandNetwork                                                                                                  \
5862     CommissioningClusterAddThreadNetworkResponse(errorCode, debugText)                                                             \
5863         emberAfFillExternalBuffer(mask,                                                                                            \
5864                                                                                                                                    \
5865                                   ZCL_ADD_THREAD_NETWORK_RESPONSE_COMMAND_ID, "uu", errorCode, debugText);
5866
5867 /** @brief Command description for UpdateThreadNetwork
5868  *
5869  * Command: UpdateThreadNetwork
5870  * @param operationalDataset OCTET_STRING
5871  * @param breadcrumb INT64U
5872  * @param timeoutMs INT32U
5873  */
5874 #define emberAfFillCommandNetwork                                                                                                  \
5875     CommissioningClusterUpdateThreadNetwork(operationalDataset, breadcrumb, timeoutMs)                                             \
5876         emberAfFillExternalBuffer(mask,                                                                                            \
5877                                                                                                                                    \
5878                                   ZCL_UPDATE_THREAD_NETWORK_COMMAND_ID, "uuu", operationalDataset, breadcrumb, timeoutMs);
5879
5880 /** @brief Command description for UpdateThreadNetworkResponse
5881  *
5882  * Command: UpdateThreadNetworkResponse
5883  * @param errorCode INT8U
5884  * @param debugText CHAR_STRING
5885  */
5886 #define emberAfFillCommandNetwork                                                                                                  \
5887     CommissioningClusterUpdateThreadNetworkResponse(errorCode, debugText)                                                          \
5888         emberAfFillExternalBuffer(mask,                                                                                            \
5889                                                                                                                                    \
5890                                   ZCL_UPDATE_THREAD_NETWORK_RESPONSE_COMMAND_ID, "uu", errorCode, debugText);
5891
5892 /** @brief Command description for RemoveNetwork
5893  *
5894  * Command: RemoveNetwork
5895  * @param NetworkID OCTET_STRING
5896  * @param Breadcrumb INT64U
5897  * @param TimeoutMs INT32U
5898  */
5899 #define emberAfFillCommandNetwork                                                                                                  \
5900     CommissioningClusterRemoveNetwork(NetworkID, Breadcrumb, TimeoutMs)                                                            \
5901         emberAfFillExternalBuffer(mask,                                                                                            \
5902                                                                                                                                    \
5903                                   ZCL_REMOVE_NETWORK_COMMAND_ID, "uuu", NetworkID, Breadcrumb, TimeoutMs);
5904
5905 /** @brief Command description for RemoveNetworkResponse
5906  *
5907  * Command: RemoveNetworkResponse
5908  * @param errorCode INT8U
5909  * @param debugText CHAR_STRING
5910  */
5911 #define emberAfFillCommandNetwork                                                                                                  \
5912     CommissioningClusterRemoveNetworkResponse(errorCode, debugText)                                                                \
5913         emberAfFillExternalBuffer(mask,                                                                                            \
5914                                                                                                                                    \
5915                                   ZCL_REMOVE_NETWORK_RESPONSE_COMMAND_ID, "uu", errorCode, debugText);
5916
5917 /** @brief Command description for EnableNetwork
5918  *
5919  * Command: EnableNetwork
5920  * @param networkID OCTET_STRING
5921  * @param breadcrumb INT64U
5922  * @param timeoutMs INT32U
5923  */
5924 #define emberAfFillCommandNetwork                                                                                                  \
5925     CommissioningClusterEnableNetwork(networkID, breadcrumb, timeoutMs)                                                            \
5926         emberAfFillExternalBuffer(mask,                                                                                            \
5927                                                                                                                                    \
5928                                   ZCL_ENABLE_NETWORK_COMMAND_ID, "uuu", networkID, breadcrumb, timeoutMs);
5929
5930 /** @brief Command description for EnableNetworkResponse
5931  *
5932  * Command: EnableNetworkResponse
5933  * @param errorCode INT8U
5934  * @param debugText CHAR_STRING
5935  */
5936 #define emberAfFillCommandNetwork                                                                                                  \
5937     CommissioningClusterEnableNetworkResponse(errorCode, debugText)                                                                \
5938         emberAfFillExternalBuffer(mask,                                                                                            \
5939                                                                                                                                    \
5940                                   ZCL_ENABLE_NETWORK_RESPONSE_COMMAND_ID, "uu", errorCode, debugText);
5941
5942 /** @brief Command description for DisableNetwork
5943  *
5944  * Command: DisableNetwork
5945  * @param networkID OCTET_STRING
5946  * @param breadcrumb INT64U
5947  * @param timeoutMs INT32U
5948  */
5949 #define emberAfFillCommandNetwork                                                                                                  \
5950     CommissioningClusterDisableNetwork(networkID, breadcrumb, timeoutMs)                                                           \
5951         emberAfFillExternalBuffer(mask,                                                                                            \
5952                                                                                                                                    \
5953                                   ZCL_DISABLE_NETWORK_COMMAND_ID, "uuu", networkID, breadcrumb, timeoutMs);
5954
5955 /** @brief Command description for DisableNetworkResponse
5956  *
5957  * Command: DisableNetworkResponse
5958  * @param errorCode INT8U
5959  * @param debugText CHAR_STRING
5960  */
5961 #define emberAfFillCommandNetwork                                                                                                  \
5962     CommissioningClusterDisableNetworkResponse(errorCode, debugText)                                                               \
5963         emberAfFillExternalBuffer(mask,                                                                                            \
5964                                                                                                                                    \
5965                                   ZCL_DISABLE_NETWORK_RESPONSE_COMMAND_ID, "uu", errorCode, debugText);
5966
5967 /** @brief Command description for GetLastNetworkCommissioningResult
5968  *
5969  * Command: GetLastNetworkCommissioningResult
5970  * @param timeoutMs INT32U
5971  */
5972 #define emberAfFillCommandNetwork                                                                                                  \
5973     CommissioningClusterGetLastNetworkCommissioningResult(timeoutMs)                                                               \
5974         emberAfFillExternalBuffer(mask,                                                                                            \
5975                                                                                                                                    \
5976                                   ZCL_GET_LAST_NETWORK_COMMISSIONING_RESULT_COMMAND_ID, "u", timeoutMs);
5977
5978 /** @brief Command description for Bind
5979  *
5980  * Command: Bind
5981  * @param nodeId NODE_ID
5982  * @param groupId GROUP_ID
5983  * @param endpointId ENDPOINT_ID
5984  * @param clusterId CLUSTER_ID
5985  */
5986 #define emberAfFillCommandBindingClusterBind(nodeId, groupId, endpointId, clusterId)                                               \
5987     emberAfFillExternalBuffer(mask,                                                                                                \
5988                                                                                                                                    \
5989                               ZCL_BIND_COMMAND_ID, "uuuu", nodeId, groupId, endpointId, clusterId);
5990
5991 /** @brief Command description for Unbind
5992  *
5993  * Command: Unbind
5994  * @param nodeId NODE_ID
5995  * @param groupId GROUP_ID
5996  * @param endpointId ENDPOINT_ID
5997  * @param clusterId CLUSTER_ID
5998  */
5999 #define emberAfFillCommandBindingClusterUnbind(nodeId, groupId, endpointId, clusterId)                                             \
6000     emberAfFillExternalBuffer(mask,                                                                                                \
6001                                                                                                                                    \
6002                               ZCL_UNBIND_COMMAND_ID, "uuuu", nodeId, groupId, endpointId, clusterId);
6003
6004 /** @brief Command description for PlayRequest
6005  *
6006  * Command: PlayRequest
6007  */
6008 #define emberAfFillCommandMedia                                                                                                    \
6009     PlaybackClusterPlayRequest() emberAfFillExternalBuffer(mask,                                                                   \
6010                                                                                                                                    \
6011                                                            ZCL_PLAY_REQUEST_COMMAND_ID, "", );
6012
6013 /** @brief Command description for PauseRequest
6014  *
6015  * Command: PauseRequest
6016  */
6017 #define emberAfFillCommandMedia                                                                                                    \
6018     PlaybackClusterPauseRequest() emberAfFillExternalBuffer(mask,                                                                  \
6019                                                                                                                                    \
6020                                                             ZCL_PAUSE_REQUEST_COMMAND_ID, "", );
6021
6022 /** @brief Command description for StopRequest
6023  *
6024  * Command: StopRequest
6025  */
6026 #define emberAfFillCommandMedia                                                                                                    \
6027     PlaybackClusterStopRequest() emberAfFillExternalBuffer(mask,                                                                   \
6028                                                                                                                                    \
6029                                                            ZCL_STOP_REQUEST_COMMAND_ID, "", );
6030
6031 /** @brief Command description for StartOverRequest
6032  *
6033  * Command: StartOverRequest
6034  */
6035 #define emberAfFillCommandMedia                                                                                                    \
6036     PlaybackClusterStartOverRequest() emberAfFillExternalBuffer(mask,                                                              \
6037                                                                                                                                    \
6038                                                                 ZCL_START_OVER_REQUEST_COMMAND_ID, "", );
6039
6040 /** @brief Command description for PreviousRequest
6041  *
6042  * Command: PreviousRequest
6043  */
6044 #define emberAfFillCommandMedia                                                                                                    \
6045     PlaybackClusterPreviousRequest() emberAfFillExternalBuffer(mask,                                                               \
6046                                                                                                                                    \
6047                                                                ZCL_PREVIOUS_REQUEST_COMMAND_ID, "", );
6048
6049 /** @brief Command description for NextRequest
6050  *
6051  * Command: NextRequest
6052  */
6053 #define emberAfFillCommandMedia                                                                                                    \
6054     PlaybackClusterNextRequest() emberAfFillExternalBuffer(mask,                                                                   \
6055                                                                                                                                    \
6056                                                            ZCL_NEXT_REQUEST_COMMAND_ID, "", );
6057
6058 /** @brief Command description for RewindRequest
6059  *
6060  * Command: RewindRequest
6061  */
6062 #define emberAfFillCommandMedia                                                                                                    \
6063     PlaybackClusterRewindRequest() emberAfFillExternalBuffer(mask,                                                                 \
6064                                                                                                                                    \
6065                                                              ZCL_REWIND_REQUEST_COMMAND_ID, "", );
6066
6067 /** @brief Command description for FastForwardRequest
6068  *
6069  * Command: FastForwardRequest
6070  */
6071 #define emberAfFillCommandMedia                                                                                                    \
6072     PlaybackClusterFastForwardRequest() emberAfFillExternalBuffer(mask,                                                            \
6073                                                                                                                                    \
6074                                                                   ZCL_FAST_FORWARD_REQUEST_COMMAND_ID, "", );
6075
6076 /** @brief Command description for SkipForwardRequest
6077  *
6078  * Command: SkipForwardRequest
6079  */
6080 #define emberAfFillCommandMedia                                                                                                    \
6081     PlaybackClusterSkipForwardRequest() emberAfFillExternalBuffer(mask,                                                            \
6082                                                                                                                                    \
6083                                                                   ZCL_SKIP_FORWARD_REQUEST_COMMAND_ID, "", );
6084
6085 /** @brief Command description for SkipBackwardRequest
6086  *
6087  * Command: SkipBackwardRequest
6088  */
6089 #define emberAfFillCommandMedia                                                                                                    \
6090     PlaybackClusterSkipBackwardRequest() emberAfFillExternalBuffer(mask,                                                           \
6091                                                                                                                                    \
6092                                                                    ZCL_SKIP_BACKWARD_REQUEST_COMMAND_ID, "", );
6093
6094 /** @brief Command description for LaunchContent
6095  *
6096  * Command: LaunchContent
6097  * @param contentLaunchStatus ContentLaunchStatus
6098  */
6099 #define emberAfFillCommandContent                                                                                                  \
6100     LaunchClusterLaunchContent(contentLaunchStatus)                                                                                \
6101         emberAfFillExternalBuffer(mask,                                                                                            \
6102                                                                                                                                    \
6103                                   ZCL_LAUNCH_CONTENT_COMMAND_ID, "u", contentLaunchStatus);
6104
6105 /** @brief Command description for LaunchURL
6106  *
6107  * Command: LaunchURL
6108  * @param contentLaunchStatus ContentLaunchStatus
6109  */
6110 #define emberAfFillCommandContent                                                                                                  \
6111     LaunchClusterLaunchURL(contentLaunchStatus) emberAfFillExternalBuffer(mask,                                                    \
6112                                                                                                                                    \
6113                                                                           ZCL_LAUNCH_URL_COMMAND_ID, "u", contentLaunchStatus);
6114
6115 /** @brief Command description for CommandOne
6116  *
6117  * Command: CommandOne
6118  * @param argOne INT8U
6119  * @param argOne INT8U
6120  */
6121 #define emberAfFillCommandSample                                                                                                   \
6122     Mfg Specific ClusterClusterCommandOne(argOne, argOne)                                                                          \
6123         emberAfFillExternalBuffer(mask,                                                                                            \
6124                                                                                                                                    \
6125                                   ZCL_COMMAND_ONE_COMMAND_ID, "uu", argOne, argOne);
6126
6127 /** @brief Command description for SetToken
6128  *
6129  * Command: SetToken
6130  * @param token INT16U
6131  * @param token INT16U
6132  * @param data OCTET_STRING
6133  * @param data OCTET_STRING
6134  */
6135 #define emberAfFillCommandConfiguration                                                                                            \
6136     ClusterClusterSetToken(token, token, data, data)                                                                               \
6137         emberAfFillExternalBuffer(mask,                                                                                            \
6138                                                                                                                                    \
6139                                   ZCL_SET_TOKEN_COMMAND_ID, "uuuu", token, token, data, data);
6140
6141 /** @brief Command description for LockTokens
6142  *
6143  * Command: LockTokens
6144  */
6145 #define emberAfFillCommandConfiguration                                                                                            \
6146     ClusterClusterLockTokens() emberAfFillExternalBuffer(mask,                                                                     \
6147                                                                                                                                    \
6148                                                          ZCL_LOCK_TOKENS_COMMAND_ID, "", );
6149
6150 /** @brief Command description for ReadTokens
6151  *
6152  * Command: ReadTokens
6153  * @param token INT16U
6154  */
6155 #define emberAfFillCommandConfiguration                                                                                            \
6156     ClusterClusterReadTokens(token) emberAfFillExternalBuffer(mask,                                                                \
6157                                                                                                                                    \
6158                                                               ZCL_READ_TOKENS_COMMAND_ID, "u", token);
6159
6160 /** @brief Command description for UnlockTokens
6161  *
6162  * Command: UnlockTokens
6163  * @param data OCTET_STRING
6164  */
6165 #define emberAfFillCommandConfiguration                                                                                            \
6166     ClusterClusterUnlockTokens(data) emberAfFillExternalBuffer(mask,                                                               \
6167                                                                                                                                    \
6168                                                                ZCL_UNLOCK_TOKENS_COMMAND_ID, "u", data);
6169
6170 /** @brief Command description for stream
6171  *
6172  * Command: stream
6173  * @param channel INT8U
6174  * @param power INT8S
6175  * @param time INT16U
6176  */
6177 #define emberAfFillCommandMFGLIB                                                                                                   \
6178     ClusterClusterstream(channel, power, time) emberAfFillExternalBuffer(mask,                                                     \
6179                                                                                                                                    \
6180                                                                          ZCL_STREAM_COMMAND_ID, "uuu", channel, power, time);
6181
6182 /** @brief Command description for tone
6183  *
6184  * Command: tone
6185  * @param channel INT8U
6186  * @param power INT8S
6187  * @param time INT16U
6188  */
6189 #define emberAfFillCommandMFGLIB                                                                                                   \
6190     ClusterClustertone(channel, power, time) emberAfFillExternalBuffer(mask,                                                       \
6191                                                                                                                                    \
6192                                                                        ZCL_TONE_COMMAND_ID, "uuu", channel, power, time);
6193
6194 /** @brief Command description for rxMode
6195  *
6196  * Command: rxMode
6197  * @param channel INT8U
6198  * @param power INT8S
6199  * @param time INT16U
6200  */
6201 #define emberAfFillCommandMFGLIB                                                                                                   \
6202     ClusterClusterrxMode(channel, power, time) emberAfFillExternalBuffer(mask,                                                     \
6203                                                                                                                                    \
6204                                                                          ZCL_RX_MODE_COMMAND_ID, "uuu", channel, power, time);
6205
6206 /** @brief Command description for EnableApsLinkKeyAuthorization
6207  *
6208  * Command: EnableApsLinkKeyAuthorization
6209  * @param numberExemptClusters INT8U
6210  * @param clusterId CLUSTER_ID
6211  * @param clusterId CLUSTER_ID []
6212  * @param clusterIdLen int
6213  * @param apsLinkKeyAuthStatus BOOLEAN
6214  */
6215 #define emberAfFillCommandSL                                                                                                       \
6216     Works With All HubsClusterEnableApsLinkKeyAuthorization(numberExemptClusters, clusterId, clusterId, clusterIdLen,              \
6217                                                             apsLinkKeyAuthStatus)                                                  \
6218         emberAfFillExternalBuffer(mask,                                                                                            \
6219                                                                                                                                    \
6220                                   ZCL_ENABLE_APS_LINK_KEY_AUTHORIZATION_COMMAND_ID, "uubu", numberExemptClusters, clusterId,       \
6221                                   clusterId, clusterIdLen, apsLinkKeyAuthStatus);
6222
6223 /** @brief Command description for DisableApsLinkKeyAuthorization
6224  *
6225  * Command: DisableApsLinkKeyAuthorization
6226  * @param numberExemptClusters INT8U
6227  * @param powerNotificationReason WwahPowerNotificationReason
6228  * @param clusterId CLUSTER_ID []
6229  * @param clusterIdLen int
6230  * @param manufacturerId INT16U
6231  * @param manufacturerReasonLength INT8U
6232  * @param manufacturerReason INT8U []
6233  * @param manufacturerReasonLen int
6234  */
6235 #define emberAfFillCommandSL                                                                                                       \
6236     Works With All HubsClusterDisableApsLinkKeyAuthorization(numberExemptClusters, powerNotificationReason, clusterId,             \
6237                                                              clusterIdLen, manufacturerId, manufacturerReasonLength,               \
6238                                                              manufacturerReason, manufacturerReasonLen)                            \
6239         emberAfFillExternalBuffer(mask,                                                                                            \
6240                                                                                                                                    \
6241                                   ZCL_DISABLE_APS_LINK_KEY_AUTHORIZATION_COMMAND_ID, "uubuub", numberExemptClusters,               \
6242                                   powerNotificationReason, clusterId, clusterIdLen, manufacturerId, manufacturerReasonLength,      \
6243                                   manufacturerReason, manufacturerReasonLen);
6244
6245 /** @brief Command description for ApsLinkKeyAuthorizationQuery
6246  *
6247  * Command: ApsLinkKeyAuthorizationQuery
6248  * @param clusterId CLUSTER_ID
6249  * @param powerNotificationReason WwahPowerNotificationReason
6250  * @param manufacturerId INT16U
6251  * @param manufacturerReasonLength INT8U
6252  * @param manufacturerReason INT8U []
6253  * @param manufacturerReasonLen int
6254  */
6255 #define emberAfFillCommandSL                                                                                                       \
6256     Works With All HubsClusterApsLinkKeyAuthorizationQuery(clusterId, powerNotificationReason, manufacturerId,                     \
6257                                                            manufacturerReasonLength, manufacturerReason, manufacturerReasonLen)    \
6258         emberAfFillExternalBuffer(mask,                                                                                            \
6259                                                                                                                                    \
6260                                   ZCL_APS_LINK_KEY_AUTHORIZATION_QUERY_COMMAND_ID, "uuuub", clusterId, powerNotificationReason,    \
6261                                   manufacturerId, manufacturerReasonLength, manufacturerReason, manufacturerReasonLen);
6262
6263 /** @brief Command description for RequestNewApsLinkKey
6264  *
6265  * Command: RequestNewApsLinkKey
6266  * @param deviceEui64 IEEE_ADDRESS
6267  * @param deviceShort INT16U
6268  */
6269 #define emberAfFillCommandSL                                                                                                       \
6270     Works With All HubsClusterRequestNewApsLinkKey(deviceEui64, deviceShort)                                                       \
6271         emberAfFillExternalBuffer(mask,                                                                                            \
6272                                                                                                                                    \
6273                                   ZCL_REQUEST_NEW_APS_LINK_KEY_COMMAND_ID, "uu", deviceEui64, deviceShort);
6274
6275 /** @brief Command description for EnableWwahAppEventRetryAlgorithm
6276  *
6277  * Command: EnableWwahAppEventRetryAlgorithm
6278  * @param firstBackoffTimeSeconds INT8U
6279  * @param numberExemptClusters INT8U
6280  * @param backoffSeqCommonRatio INT8U
6281  * @param clusterId CLUSTER_ID []
6282  * @param clusterIdLen int
6283  * @param maxBackoffTimeSeconds INT32U
6284  * @param maxRedeliveryAttempts INT8U
6285  */
6286 #define emberAfFillCommandSL                                                                                                       \
6287     Works With All HubsClusterEnableWwahAppEventRetryAlgorithm(                                                                    \
6288         firstBackoffTimeSeconds, numberExemptClusters, backoffSeqCommonRatio, clusterId, clusterIdLen, maxBackoffTimeSeconds,      \
6289         maxRedeliveryAttempts) emberAfFillExternalBuffer(mask,                                                                     \
6290                                                                                                                                    \
6291                                                          ZCL_ENABLE_WWAH_APP_EVENT_RETRY_ALGORITHM_COMMAND_ID, "uuubuu",           \
6292                                                          firstBackoffTimeSeconds, numberExemptClusters, backoffSeqCommonRatio,     \
6293                                                          clusterId, clusterIdLen, maxBackoffTimeSeconds, maxRedeliveryAttempts);
6294
6295 /** @brief Command description for DisableWwahAppEventRetryAlgorithm
6296  *
6297  * Command: DisableWwahAppEventRetryAlgorithm
6298  * @param currentPowerMode INT32U
6299  * @param availablePowerSources INT32U
6300  * @param currentPowerSource INT32U
6301  * @param currentPowerSourceLevel INT32U
6302  */
6303 #define emberAfFillCommandSL                                                                                                       \
6304     Works With All HubsClusterDisableWwahAppEventRetryAlgorithm(currentPowerMode, availablePowerSources, currentPowerSource,       \
6305                                                                 currentPowerSourceLevel)                                           \
6306         emberAfFillExternalBuffer(mask,                                                                                            \
6307                                                                                                                                    \
6308                                   ZCL_DISABLE_WWAH_APP_EVENT_RETRY_ALGORITHM_COMMAND_ID, "uuuu", currentPowerMode,                 \
6309                                   availablePowerSources, currentPowerSource, currentPowerSourceLevel);
6310
6311 /** @brief Command description for RequestTime
6312  *
6313  * Command: RequestTime
6314  * @param debugReportId INT8U
6315  * @param debugReportSize INT32U
6316  */
6317 #define emberAfFillCommandSL                                                                                                       \
6318     Works With All HubsClusterRequestTime(debugReportId, debugReportSize)                                                          \
6319         emberAfFillExternalBuffer(mask,                                                                                            \
6320                                                                                                                                    \
6321                                   ZCL_REQUEST_TIME_COMMAND_ID, "uu", debugReportId, debugReportSize);
6322
6323 /** @brief Command description for EnableWwahRejoinAlgorithm
6324  *
6325  * Command: EnableWwahRejoinAlgorithm
6326  * @param fastRejoinTimeoutSeconds INT16U
6327  * @param debugReportId INT8U
6328  * @param durationBetweenRejoinsSeconds INT16U
6329  * @param debugReportData INT8U []
6330  * @param debugReportDataLen int
6331  * @param fastRejoinFirstBackoffSeconds INT16U
6332  * @param maxBackoffTimeSeconds INT16U
6333  * @param maxBackoffIterations INT16U
6334  */
6335 #define emberAfFillCommandSL                                                                                                       \
6336     Works With All HubsClusterEnableWwahRejoinAlgorithm(fastRejoinTimeoutSeconds, debugReportId, durationBetweenRejoinsSeconds,    \
6337                                                         debugReportData, debugReportDataLen, fastRejoinFirstBackoffSeconds,        \
6338                                                         maxBackoffTimeSeconds, maxBackoffIterations)                               \
6339         emberAfFillExternalBuffer(mask,                                                                                            \
6340                                                                                                                                    \
6341                                   ZCL_ENABLE_WWAH_REJOIN_ALGORITHM_COMMAND_ID, "uuubuuu", fastRejoinTimeoutSeconds, debugReportId, \
6342                                   durationBetweenRejoinsSeconds, debugReportData, debugReportDataLen,                              \
6343                                   fastRejoinFirstBackoffSeconds, maxBackoffTimeSeconds, maxBackoffIterations);
6344
6345 /** @brief Command description for DisableWwahRejoinAlgorithm
6346  *
6347  * Command: DisableWwahRejoinAlgorithm
6348  * @param numberOfClusters INT8U
6349  * @param clusterId CLUSTER_ID []
6350  * @param clusterIdLen int
6351  */
6352 #define emberAfFillCommandSL                                                                                                       \
6353     Works With All HubsClusterDisableWwahRejoinAlgorithm(numberOfClusters, clusterId, clusterIdLen)                                \
6354         emberAfFillExternalBuffer(mask,                                                                                            \
6355                                                                                                                                    \
6356                                   ZCL_DISABLE_WWAH_REJOIN_ALGORITHM_COMMAND_ID, "ub", numberOfClusters, clusterId, clusterIdLen);
6357
6358 /** @brief Command description for SetIasZoneEnrollmentMethod
6359  *
6360  * Command: SetIasZoneEnrollmentMethod
6361  * @param enrollmentMode WwahIasZoneEnrollmentMode
6362  * @param numberOfBeacons INT8U
6363  * @param beacon WwahBeaconSurvey []
6364  * @param beaconLen int
6365  */
6366 #define emberAfFillCommandSL                                                                                                       \
6367     Works With All HubsClusterSetIasZoneEnrollmentMethod(enrollmentMode, numberOfBeacons, beacon, beaconLen)                       \
6368         emberAfFillExternalBuffer(mask,                                                                                            \
6369                                                                                                                                    \
6370                                   ZCL_SET_IAS_ZONE_ENROLLMENT_METHOD_COMMAND_ID, "uub", enrollmentMode, numberOfBeacons, beacon,   \
6371                                   beaconLen);
6372
6373 /** @brief Command description for ClearBindingTable
6374  *
6375  * Command: ClearBindingTable
6376  */
6377 #define emberAfFillCommandSL                                                                                                       \
6378     Works With All HubsClusterClearBindingTable() emberAfFillExternalBuffer(mask,                                                  \
6379                                                                                                                                    \
6380                                                                             ZCL_CLEAR_BINDING_TABLE_COMMAND_ID, "", );
6381
6382 /** @brief Command description for EnablePeriodicRouterCheckIns
6383  *
6384  * Command: EnablePeriodicRouterCheckIns
6385  * @param checkInInterval INT16U
6386  */
6387 #define emberAfFillCommandSL                                                                                                       \
6388     Works With All HubsClusterEnablePeriodicRouterCheckIns(checkInInterval)                                                        \
6389         emberAfFillExternalBuffer(mask,                                                                                            \
6390                                                                                                                                    \
6391                                   ZCL_ENABLE_PERIODIC_ROUTER_CHECK_INS_COMMAND_ID, "u", checkInInterval);
6392
6393 /** @brief Command description for DisablePeriodicRouterCheckIns
6394  *
6395  * Command: DisablePeriodicRouterCheckIns
6396  */
6397 #define emberAfFillCommandSL                                                                                                       \
6398     Works With All HubsClusterDisablePeriodicRouterCheckIns()                                                                      \
6399         emberAfFillExternalBuffer(mask,                                                                                            \
6400                                                                                                                                    \
6401                                   ZCL_DISABLE_PERIODIC_ROUTER_CHECK_INS_COMMAND_ID, "", );
6402
6403 /** @brief Command description for SetMacPollFailureWaitTime
6404  *
6405  * Command: SetMacPollFailureWaitTime
6406  * @param waitTime INT8U
6407  */
6408 #define emberAfFillCommandSL                                                                                                       \
6409     Works With All HubsClusterSetMacPollFailureWaitTime(waitTime)                                                                  \
6410         emberAfFillExternalBuffer(mask,                                                                                            \
6411                                                                                                                                    \
6412                                   ZCL_SET_MAC_POLL_FAILURE_WAIT_TIME_COMMAND_ID, "u", waitTime);
6413
6414 /** @brief Command description for SetPendingNetworkUpdate
6415  *
6416  * Command: SetPendingNetworkUpdate
6417  * @param channel INT8U
6418  * @param panId INT16U
6419  */
6420 #define emberAfFillCommandSL                                                                                                       \
6421     Works With All HubsClusterSetPendingNetworkUpdate(channel, panId)                                                              \
6422         emberAfFillExternalBuffer(mask,                                                                                            \
6423                                                                                                                                    \
6424                                   ZCL_SET_PENDING_NETWORK_UPDATE_COMMAND_ID, "uu", channel, panId);
6425
6426 /** @brief Command description for RequireApsAcksOnUnicasts
6427  *
6428  * Command: RequireApsAcksOnUnicasts
6429  * @param numberExemptClusters INT8U
6430  * @param clusterId CLUSTER_ID []
6431  * @param clusterIdLen int
6432  */
6433 #define emberAfFillCommandSL                                                                                                       \
6434     Works With All HubsClusterRequireApsAcksOnUnicasts(numberExemptClusters, clusterId, clusterIdLen) emberAfFillExternalBuffer(   \
6435         mask,                                                                                                                      \
6436                                                                                                                                    \
6437         ZCL_REQUIRE_APS_ACKS_ON_UNICASTS_COMMAND_ID, "ub", numberExemptClusters, clusterId, clusterIdLen);
6438
6439 /** @brief Command description for RemoveApsAcksOnUnicastsRequirement
6440  *
6441  * Command: RemoveApsAcksOnUnicastsRequirement
6442  */
6443 #define emberAfFillCommandSL                                                                                                       \
6444     Works With All HubsClusterRemoveApsAcksOnUnicastsRequirement()                                                                 \
6445         emberAfFillExternalBuffer(mask,                                                                                            \
6446                                                                                                                                    \
6447                                   ZCL_REMOVE_APS_ACKS_ON_UNICASTS_REQUIREMENT_COMMAND_ID, "", );
6448
6449 /** @brief Command description for ApsAckRequirementQuery
6450  *
6451  * Command: ApsAckRequirementQuery
6452  */
6453 #define emberAfFillCommandSL                                                                                                       \
6454     Works With All HubsClusterApsAckRequirementQuery() emberAfFillExternalBuffer(mask,                                             \
6455                                                                                                                                    \
6456                                                                                  ZCL_APS_ACK_REQUIREMENT_QUERY_COMMAND_ID, "", );
6457
6458 /** @brief Command description for DebugReportQuery
6459  *
6460  * Command: DebugReportQuery
6461  * @param debugReportId INT8U
6462  */
6463 #define emberAfFillCommandSL                                                                                                       \
6464     Works With All HubsClusterDebugReportQuery(debugReportId)                                                                      \
6465         emberAfFillExternalBuffer(mask,                                                                                            \
6466                                                                                                                                    \
6467                                   ZCL_DEBUG_REPORT_QUERY_COMMAND_ID, "u", debugReportId);
6468
6469 /** @brief Command description for SurveyBeacons
6470  *
6471  * Command: SurveyBeacons
6472  * @param standardBeacons BOOLEAN
6473  */
6474 #define emberAfFillCommandSL                                                                                                       \
6475     Works With All HubsClusterSurveyBeacons(standardBeacons)                                                                       \
6476         emberAfFillExternalBuffer(mask,                                                                                            \
6477                                                                                                                                    \
6478                                   ZCL_SURVEY_BEACONS_COMMAND_ID, "u", standardBeacons);
6479
6480 /** @brief Command description for DisableOtaDowngrades
6481  *
6482  * Command: DisableOtaDowngrades
6483  */
6484 #define emberAfFillCommandSL                                                                                                       \
6485     Works With All HubsClusterDisableOtaDowngrades() emberAfFillExternalBuffer(mask,                                               \
6486                                                                                                                                    \
6487                                                                                ZCL_DISABLE_OTA_DOWNGRADES_COMMAND_ID, "", );
6488
6489 /** @brief Command description for DisableMgmtLeaveWithoutRejoin
6490  *
6491  * Command: DisableMgmtLeaveWithoutRejoin
6492  */
6493 #define emberAfFillCommandSL                                                                                                       \
6494     Works With All HubsClusterDisableMgmtLeaveWithoutRejoin()                                                                      \
6495         emberAfFillExternalBuffer(mask,                                                                                            \
6496                                                                                                                                    \
6497                                   ZCL_DISABLE_MGMT_LEAVE_WITHOUT_REJOIN_COMMAND_ID, "", );
6498
6499 /** @brief Command description for DisableTouchlinkInterpanMessageSupport
6500  *
6501  * Command: DisableTouchlinkInterpanMessageSupport
6502  */
6503 #define emberAfFillCommandSL                                                                                                       \
6504     Works With All HubsClusterDisableTouchlinkInterpanMessageSupport()                                                             \
6505         emberAfFillExternalBuffer(mask,                                                                                            \
6506                                                                                                                                    \
6507                                   ZCL_DISABLE_TOUCHLINK_INTERPAN_MESSAGE_SUPPORT_COMMAND_ID, "", );
6508
6509 /** @brief Command description for EnableWwahParentClassification
6510  *
6511  * Command: EnableWwahParentClassification
6512  */
6513 #define emberAfFillCommandSL                                                                                                       \
6514     Works With All HubsClusterEnableWwahParentClassification()                                                                     \
6515         emberAfFillExternalBuffer(mask,                                                                                            \
6516                                                                                                                                    \
6517                                   ZCL_ENABLE_WWAH_PARENT_CLASSIFICATION_COMMAND_ID, "", );
6518
6519 /** @brief Command description for DisableWwahParentClassification
6520  *
6521  * Command: DisableWwahParentClassification
6522  */
6523 #define emberAfFillCommandSL                                                                                                       \
6524     Works With All HubsClusterDisableWwahParentClassification()                                                                    \
6525         emberAfFillExternalBuffer(mask,                                                                                            \
6526                                                                                                                                    \
6527                                   ZCL_DISABLE_WWAH_PARENT_CLASSIFICATION_COMMAND_ID, "", );
6528
6529 /** @brief Command description for EnableTcSecurityOnNtwkKeyRotation
6530  *
6531  * Command: EnableTcSecurityOnNtwkKeyRotation
6532  */
6533 #define emberAfFillCommandSL                                                                                                       \
6534     Works With All HubsClusterEnableTcSecurityOnNtwkKeyRotation()                                                                  \
6535         emberAfFillExternalBuffer(mask,                                                                                            \
6536                                                                                                                                    \
6537                                   ZCL_ENABLE_TC_SECURITY_ON_NTWK_KEY_ROTATION_COMMAND_ID, "", );
6538
6539 /** @brief Command description for EnableWwahBadParentRecovery
6540  *
6541  * Command: EnableWwahBadParentRecovery
6542  */
6543 #define emberAfFillCommandSL                                                                                                       \
6544     Works With All HubsClusterEnableWwahBadParentRecovery()                                                                        \
6545         emberAfFillExternalBuffer(mask,                                                                                            \
6546                                                                                                                                    \
6547                                   ZCL_ENABLE_WWAH_BAD_PARENT_RECOVERY_COMMAND_ID, "", );
6548
6549 /** @brief Command description for DisableWwahBadParentRecovery
6550  *
6551  * Command: DisableWwahBadParentRecovery
6552  */
6553 #define emberAfFillCommandSL                                                                                                       \
6554     Works With All HubsClusterDisableWwahBadParentRecovery()                                                                       \
6555         emberAfFillExternalBuffer(mask,                                                                                            \
6556                                                                                                                                    \
6557                                   ZCL_DISABLE_WWAH_BAD_PARENT_RECOVERY_COMMAND_ID, "", );
6558
6559 /** @brief Command description for EnableConfigurationMode
6560  *
6561  * Command: EnableConfigurationMode
6562  */
6563 #define emberAfFillCommandSL                                                                                                       \
6564     Works With All HubsClusterEnableConfigurationMode() emberAfFillExternalBuffer(mask,                                            \
6565                                                                                                                                    \
6566                                                                                   ZCL_ENABLE_CONFIGURATION_MODE_COMMAND_ID, "", );
6567
6568 /** @brief Command description for DisableConfigurationMode
6569  *
6570  * Command: DisableConfigurationMode
6571  */
6572 #define emberAfFillCommandSL                                                                                                       \
6573     Works With All HubsClusterDisableConfigurationMode()                                                                           \
6574         emberAfFillExternalBuffer(mask,                                                                                            \
6575                                                                                                                                    \
6576                                   ZCL_DISABLE_CONFIGURATION_MODE_COMMAND_ID, "", );
6577
6578 /** @brief Command description for UseTrustCenterForClusterServer
6579  *
6580  * Command: UseTrustCenterForClusterServer
6581  * @param numberOfClusters INT8U
6582  * @param clusterId CLUSTER_ID []
6583  * @param clusterIdLen int
6584  */
6585 #define emberAfFillCommandSL                                                                                                       \
6586     Works With All HubsClusterUseTrustCenterForClusterServer(numberOfClusters, clusterId, clusterIdLen) emberAfFillExternalBuffer( \
6587         mask,                                                                                                                      \
6588                                                                                                                                    \
6589         ZCL_USE_TRUST_CENTER_FOR_CLUSTER_SERVER_COMMAND_ID, "ub", numberOfClusters, clusterId, clusterIdLen);
6590
6591 /** @brief Command description for TrustCenterForClusterServerQuery
6592  *
6593  * Command: TrustCenterForClusterServerQuery
6594  */
6595 #define emberAfFillCommandSL                                                                                                       \
6596     Works With All HubsClusterTrustCenterForClusterServerQuery()                                                                   \
6597         emberAfFillExternalBuffer(mask,                                                                                            \
6598                                                                                                                                    \
6599                                   ZCL_TRUST_CENTER_FOR_CLUSTER_SERVER_QUERY_COMMAND_ID, "", );
6600
6601 /** @brief Command description for UseTrustCenterForClusterServerResponse
6602  *
6603  * Command: UseTrustCenterForClusterServerResponse
6604  * @param status Status
6605  * @param clusterStatusLength INT8U
6606  * @param clusterStatus WwahClusterStatusToUseTC []
6607  * @param clusterStatusLen int
6608  */
6609 #define emberAfFillCommandSL                                                                                                       \
6610     Works With All HubsClusterUseTrustCenterForClusterServerResponse(status, clusterStatusLength, clusterStatus, clusterStatusLen) \
6611         emberAfFillExternalBuffer(mask,                                                                                            \
6612                                                                                                                                    \
6613                                   ZCL_USE_TRUST_CENTER_FOR_CLUSTER_SERVER_RESPONSE_COMMAND_ID, "uub", status, clusterStatusLength, \
6614                                   clusterStatus, clusterStatusLen);