src/app/util/debug-printing.h - third_party/github/project-chip/connectedhomeip - Git at Google

 /**
  *
  *    Copyright (c) 2020 Project CHIP Authors
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
  *    You may obtain a copy of the License at
  *
  *        http://www.apache.org/licenses/LICENSE-2.0
  *
  *    Unless required by applicable law or agreed to in writing, software
  *    distributed under the License is distributed on an "AS IS" BASIS,
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */

 /**
  *
  *    Copyright (c) 2020 Silicon Labs
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
  *    You may obtain a copy of the License at
  *
  *        http://www.apache.org/licenses/LICENSE-2.0
  *
  *    Unless required by applicable law or agreed to in writing, software
  *    distributed under the License is distributed on an "AS IS" BASIS,
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */
 // This file is generated by Simplicity Studio.  Please do not edit manually.
 //
 //

 #pragma once

 #include "debug-printing-test.h"

 // Printing macros for cluster: Basic
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BASIC_CLUSTER)
 #define emberAfBasicClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BASIC_CLUSTER, __VA_ARGS__)
 #define emberAfBasicClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BASIC_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfBasicClusterFlush()
 #define emberAfBasicClusterDebugExec(x)                                                                                            \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_BASIC_CLUSTER))                                                                         \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfBasicClusterPrintBuffer(buffer, len, withSpace)                                                                     \
     emberAfPrintBuffer(EMBER_AF_PRINT_BASIC_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfBasicClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BASIC_CLUSTER, (buffer))
 #else
 #define emberAfBasicClusterPrint(...)
 #define emberAfBasicClusterPrintln(...)
 #define emberAfBasicClusterFlush()
 #define emberAfBasicClusterDebugExec(x)
 #define emberAfBasicClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfBasicClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BASIC_CLUSTER)

 // Printing macros for cluster: Power Configuration
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER)
 #define emberAfPowerConfigClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER, __VA_ARGS__)
 #define emberAfPowerConfigClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfPowerConfigClusterFlush()
 #define emberAfPowerConfigClusterDebugExec(x)                                                                                      \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER))                                                                  \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfPowerConfigClusterPrintBuffer(buffer, len, withSpace)                                                               \
     emberAfPrintBuffer(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfPowerConfigClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER, (buffer))
 #else
 #define emberAfPowerConfigClusterPrint(...)
 #define emberAfPowerConfigClusterPrintln(...)
 #define emberAfPowerConfigClusterFlush()
 #define emberAfPowerConfigClusterDebugExec(x)
 #define emberAfPowerConfigClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfPowerConfigClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER)

 // Printing macros for cluster: Device Temperature Configuration
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER)
 #define emberAfDeviceTempClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER, __VA_ARGS__)
 #define emberAfDeviceTempClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfDeviceTempClusterFlush()
 #define emberAfDeviceTempClusterDebugExec(x)                                                                                       \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER))                                                                   \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfDeviceTempClusterPrintBuffer(buffer, len, withSpace)                                                                \
     emberAfPrintBuffer(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfDeviceTempClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER, (buffer))
 #else
 #define emberAfDeviceTempClusterPrint(...)
 #define emberAfDeviceTempClusterPrintln(...)
 #define emberAfDeviceTempClusterFlush()
 #define emberAfDeviceTempClusterDebugExec(x)
 #define emberAfDeviceTempClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfDeviceTempClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER)

 // Printing macros for cluster: Identify
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IDENTIFY_CLUSTER)
 #define emberAfIdentifyClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_IDENTIFY_CLUSTER, __VA_ARGS__)
 #define emberAfIdentifyClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_IDENTIFY_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfIdentifyClusterFlush()
 #define emberAfIdentifyClusterDebugExec(x)                                                                                         \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_IDENTIFY_CLUSTER))                                                                      \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfIdentifyClusterPrintBuffer(buffer, len, withSpace)                                                                  \
     emberAfPrintBuffer(EMBER_AF_PRINT_IDENTIFY_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfIdentifyClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_IDENTIFY_CLUSTER, (buffer))
 #else
 #define emberAfIdentifyClusterPrint(...)
 #define emberAfIdentifyClusterPrintln(...)
 #define emberAfIdentifyClusterFlush()
 #define emberAfIdentifyClusterDebugExec(x)
 #define emberAfIdentifyClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfIdentifyClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IDENTIFY_CLUSTER)

 // Printing macros for cluster: Groups
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GROUPS_CLUSTER)
 #define emberAfGroupsClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_GROUPS_CLUSTER, __VA_ARGS__)
 #define emberAfGroupsClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_GROUPS_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfGroupsClusterFlush()
 #define emberAfGroupsClusterDebugExec(x)                                                                                           \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_GROUPS_CLUSTER))                                                                        \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfGroupsClusterPrintBuffer(buffer, len, withSpace)                                                                    \
     emberAfPrintBuffer(EMBER_AF_PRINT_GROUPS_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfGroupsClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_GROUPS_CLUSTER, (buffer))
 #else
 #define emberAfGroupsClusterPrint(...)
 #define emberAfGroupsClusterPrintln(...)
 #define emberAfGroupsClusterFlush()
 #define emberAfGroupsClusterDebugExec(x)
 #define emberAfGroupsClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfGroupsClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GROUPS_CLUSTER)

 // Printing macros for cluster: Scenes
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SCENES_CLUSTER)
 #define emberAfScenesClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SCENES_CLUSTER, __VA_ARGS__)
 #define emberAfScenesClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SCENES_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfScenesClusterFlush()
 #define emberAfScenesClusterDebugExec(x)                                                                                           \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_SCENES_CLUSTER))                                                                        \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfScenesClusterPrintBuffer(buffer, len, withSpace)                                                                    \
     emberAfPrintBuffer(EMBER_AF_PRINT_SCENES_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfScenesClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SCENES_CLUSTER, (buffer))
 #else
 #define emberAfScenesClusterPrint(...)
 #define emberAfScenesClusterPrintln(...)
 #define emberAfScenesClusterFlush()
 #define emberAfScenesClusterDebugExec(x)
 #define emberAfScenesClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfScenesClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SCENES_CLUSTER)

 // Printing macros for cluster: On/off
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ON_OFF_CLUSTER)
 #define emberAfOnOffClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ON_OFF_CLUSTER, __VA_ARGS__)
 #define emberAfOnOffClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ON_OFF_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfOnOffClusterFlush()
 #define emberAfOnOffClusterDebugExec(x)                                                                                            \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_ON_OFF_CLUSTER))                                                                        \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfOnOffClusterPrintBuffer(buffer, len, withSpace)                                                                     \
     emberAfPrintBuffer(EMBER_AF_PRINT_ON_OFF_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfOnOffClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ON_OFF_CLUSTER, (buffer))
 #else
 #define emberAfOnOffClusterPrint(...)
 #define emberAfOnOffClusterPrintln(...)
 #define emberAfOnOffClusterFlush()
 #define emberAfOnOffClusterDebugExec(x)
 #define emberAfOnOffClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfOnOffClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ON_OFF_CLUSTER)

 // Printing macros for cluster: On/off Switch Configuration
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER)
 #define emberAfOnOffSwitchConfigClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER, __VA_ARGS__)
 #define emberAfOnOffSwitchConfigClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfOnOffSwitchConfigClusterFlush()
 #define emberAfOnOffSwitchConfigClusterDebugExec(x)                                                                                \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER))                                                          \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfOnOffSwitchConfigClusterPrintBuffer(buffer, len, withSpace)                                                         \
     emberAfPrintBuffer(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfOnOffSwitchConfigClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER, (buffer))
 #else
 #define emberAfOnOffSwitchConfigClusterPrint(...)
 #define emberAfOnOffSwitchConfigClusterPrintln(...)
 #define emberAfOnOffSwitchConfigClusterFlush()
 #define emberAfOnOffSwitchConfigClusterDebugExec(x)
 #define emberAfOnOffSwitchConfigClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfOnOffSwitchConfigClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER)

 // Printing macros for cluster: Level Control
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER)
 #define emberAfLevelControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER, __VA_ARGS__)
 #define emberAfLevelControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfLevelControlClusterFlush()
 #define emberAfLevelControlClusterDebugExec(x)                                                                                     \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER))                                                                 \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfLevelControlClusterPrintBuffer(buffer, len, withSpace)                                                              \
     emberAfPrintBuffer(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfLevelControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER, (buffer))
 #else
 #define emberAfLevelControlClusterPrint(...)
 #define emberAfLevelControlClusterPrintln(...)
 #define emberAfLevelControlClusterFlush()
 #define emberAfLevelControlClusterDebugExec(x)
 #define emberAfLevelControlClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfLevelControlClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER)

 // Printing macros for cluster: Alarms
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ALARM_CLUSTER)
 #define emberAfAlarmClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ALARM_CLUSTER, __VA_ARGS__)
 #define emberAfAlarmClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ALARM_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfAlarmClusterFlush()
 #define emberAfAlarmClusterDebugExec(x)                                                                                            \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_ALARM_CLUSTER))                                                                         \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfAlarmClusterPrintBuffer(buffer, len, withSpace)                                                                     \
     emberAfPrintBuffer(EMBER_AF_PRINT_ALARM_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfAlarmClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ALARM_CLUSTER, (buffer))
 #else
 #define emberAfAlarmClusterPrint(...)
 #define emberAfAlarmClusterPrintln(...)
 #define emberAfAlarmClusterFlush()
 #define emberAfAlarmClusterDebugExec(x)
 #define emberAfAlarmClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfAlarmClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ALARM_CLUSTER)

 // Printing macros for cluster: Time
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TIME_CLUSTER)
 #define emberAfTimeClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_TIME_CLUSTER, __VA_ARGS__)
 #define emberAfTimeClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_TIME_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfTimeClusterFlush()
 #define emberAfTimeClusterDebugExec(x)                                                                                             \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_TIME_CLUSTER))                                                                          \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfTimeClusterPrintBuffer(buffer, len, withSpace)                                                                      \
     emberAfPrintBuffer(EMBER_AF_PRINT_TIME_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfTimeClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_TIME_CLUSTER, (buffer))
 #else
 #define emberAfTimeClusterPrint(...)
 #define emberAfTimeClusterPrintln(...)
 #define emberAfTimeClusterFlush()
 #define emberAfTimeClusterDebugExec(x)
 #define emberAfTimeClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfTimeClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TIME_CLUSTER)

 // Printing macros for cluster: RSSI Location
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER)
 #define emberAfRssiLocationClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER, __VA_ARGS__)
 #define emberAfRssiLocationClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfRssiLocationClusterFlush()
 #define emberAfRssiLocationClusterDebugExec(x)                                                                                     \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER))                                                                 \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfRssiLocationClusterPrintBuffer(buffer, len, withSpace)                                                              \
     emberAfPrintBuffer(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfRssiLocationClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER, (buffer))
 #else
 #define emberAfRssiLocationClusterPrint(...)
 #define emberAfRssiLocationClusterPrintln(...)
 #define emberAfRssiLocationClusterFlush()
 #define emberAfRssiLocationClusterDebugExec(x)
 #define emberAfRssiLocationClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfRssiLocationClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER)

 // Printing macros for cluster: Binary Input (Basic)
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER)
 #define emberAfBinaryInputBasicClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER, __VA_ARGS__)
 #define emberAfBinaryInputBasicClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfBinaryInputBasicClusterFlush()
 #define emberAfBinaryInputBasicClusterDebugExec(x)                                                                                 \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER))                                                            \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfBinaryInputBasicClusterPrintBuffer(buffer, len, withSpace)                                                          \
     emberAfPrintBuffer(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfBinaryInputBasicClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER, (buffer))
 #else
 #define emberAfBinaryInputBasicClusterPrint(...)
 #define emberAfBinaryInputBasicClusterPrintln(...)
 #define emberAfBinaryInputBasicClusterFlush()
 #define emberAfBinaryInputBasicClusterDebugExec(x)
 #define emberAfBinaryInputBasicClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfBinaryInputBasicClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER)

 // Printing macros for cluster: Commissioning
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_COMMISSIONING_CLUSTER)
 #define emberAfCommissioningClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_COMMISSIONING_CLUSTER, __VA_ARGS__)
 #define emberAfCommissioningClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_COMMISSIONING_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfCommissioningClusterFlush()
 #define emberAfCommissioningClusterDebugExec(x)                                                                                    \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_COMMISSIONING_CLUSTER))                                                                 \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfCommissioningClusterPrintBuffer(buffer, len, withSpace)                                                             \
     emberAfPrintBuffer(EMBER_AF_PRINT_COMMISSIONING_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfCommissioningClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_COMMISSIONING_CLUSTER, (buffer))
 #else
 #define emberAfCommissioningClusterPrint(...)
 #define emberAfCommissioningClusterPrintln(...)
 #define emberAfCommissioningClusterFlush()
 #define emberAfCommissioningClusterDebugExec(x)
 #define emberAfCommissioningClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfCommissioningClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_COMMISSIONING_CLUSTER)

 // Printing macros for cluster: Partition
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PARTITION_CLUSTER)
 #define emberAfPartitionClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_PARTITION_CLUSTER, __VA_ARGS__)
 #define emberAfPartitionClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PARTITION_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfPartitionClusterFlush()
 #define emberAfPartitionClusterDebugExec(x)                                                                                        \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_PARTITION_CLUSTER))                                                                     \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfPartitionClusterPrintBuffer(buffer, len, withSpace)                                                                 \
     emberAfPrintBuffer(EMBER_AF_PRINT_PARTITION_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfPartitionClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_PARTITION_CLUSTER, (buffer))
 #else
 #define emberAfPartitionClusterPrint(...)
 #define emberAfPartitionClusterPrintln(...)
 #define emberAfPartitionClusterFlush()
 #define emberAfPartitionClusterDebugExec(x)
 #define emberAfPartitionClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfPartitionClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PARTITION_CLUSTER)

 // Printing macros for cluster: Over the Air Bootloading
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER)
 #define emberAfOtaBootloadClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER, __VA_ARGS__)
 #define emberAfOtaBootloadClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfOtaBootloadClusterFlush()
 #define emberAfOtaBootloadClusterDebugExec(x)                                                                                      \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER))                                                                  \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfOtaBootloadClusterPrintBuffer(buffer, len, withSpace)                                                               \
     emberAfPrintBuffer(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfOtaBootloadClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER, (buffer))
 #else
 #define emberAfOtaBootloadClusterPrint(...)
 #define emberAfOtaBootloadClusterPrintln(...)
 #define emberAfOtaBootloadClusterFlush()
 #define emberAfOtaBootloadClusterDebugExec(x)
 #define emberAfOtaBootloadClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfOtaBootloadClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER)

 // Printing macros for cluster: Power Profile
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER)
 #define emberAfPowerProfileClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER, __VA_ARGS__)
 #define emberAfPowerProfileClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfPowerProfileClusterFlush()
 #define emberAfPowerProfileClusterDebugExec(x)                                                                                     \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER))                                                                 \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfPowerProfileClusterPrintBuffer(buffer, len, withSpace)                                                              \
     emberAfPrintBuffer(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfPowerProfileClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER, (buffer))
 #else
 #define emberAfPowerProfileClusterPrint(...)
 #define emberAfPowerProfileClusterPrintln(...)
 #define emberAfPowerProfileClusterFlush()
 #define emberAfPowerProfileClusterDebugExec(x)
 #define emberAfPowerProfileClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfPowerProfileClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER)

 // Printing macros for cluster: Appliance Control
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER)
 #define emberAfApplianceControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER, __VA_ARGS__)
 #define emberAfApplianceControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfApplianceControlClusterFlush()
 #define emberAfApplianceControlClusterDebugExec(x)                                                                                 \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER))                                                             \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfApplianceControlClusterPrintBuffer(buffer, len, withSpace)                                                          \
     emberAfPrintBuffer(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfApplianceControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER, (buffer))
 #else
 #define emberAfApplianceControlClusterPrint(...)
 #define emberAfApplianceControlClusterPrintln(...)
 #define emberAfApplianceControlClusterFlush()
 #define emberAfApplianceControlClusterDebugExec(x)
 #define emberAfApplianceControlClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfApplianceControlClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER)

 // Printing macros for cluster: Poll Control
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER)
 #define emberAfPollControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER, __VA_ARGS__)
 #define emberAfPollControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfPollControlClusterFlush()
 #define emberAfPollControlClusterDebugExec(x)                                                                                      \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER))                                                                  \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfPollControlClusterPrintBuffer(buffer, len, withSpace)                                                               \
     emberAfPrintBuffer(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfPollControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER, (buffer))
 #else
 #define emberAfPollControlClusterPrint(...)
 #define emberAfPollControlClusterPrintln(...)
 #define emberAfPollControlClusterFlush()
 #define emberAfPollControlClusterDebugExec(x)
 #define emberAfPollControlClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfPollControlClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER)

 // Printing macros for cluster: Green Power
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GREEN_POWER_CLUSTER)
 #define emberAfGreenPowerClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_GREEN_POWER_CLUSTER, __VA_ARGS__)
 #define emberAfGreenPowerClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_GREEN_POWER_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfGreenPowerClusterFlush()
 #define emberAfGreenPowerClusterDebugExec(x)                                                                                       \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_GREEN_POWER_CLUSTER))                                                                   \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfGreenPowerClusterPrintBuffer(buffer, len, withSpace)                                                                \
     emberAfPrintBuffer(EMBER_AF_PRINT_GREEN_POWER_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfGreenPowerClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_GREEN_POWER_CLUSTER, (buffer))
 #else
 #define emberAfGreenPowerClusterPrint(...)
 #define emberAfGreenPowerClusterPrintln(...)
 #define emberAfGreenPowerClusterFlush()
 #define emberAfGreenPowerClusterDebugExec(x)
 #define emberAfGreenPowerClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfGreenPowerClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GREEN_POWER_CLUSTER)

 // Printing macros for cluster: Keep-Alive
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_KEEPALIVE_CLUSTER)
 #define emberAfKeepaliveClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_KEEPALIVE_CLUSTER, __VA_ARGS__)
 #define emberAfKeepaliveClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_KEEPALIVE_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfKeepaliveClusterFlush()
 #define emberAfKeepaliveClusterDebugExec(x)                                                                                        \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_KEEPALIVE_CLUSTER))                                                                     \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfKeepaliveClusterPrintBuffer(buffer, len, withSpace)                                                                 \
     emberAfPrintBuffer(EMBER_AF_PRINT_KEEPALIVE_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfKeepaliveClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_KEEPALIVE_CLUSTER, (buffer))
 #else
 #define emberAfKeepaliveClusterPrint(...)
 #define emberAfKeepaliveClusterPrintln(...)
 #define emberAfKeepaliveClusterFlush()
 #define emberAfKeepaliveClusterDebugExec(x)
 #define emberAfKeepaliveClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfKeepaliveClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_KEEPALIVE_CLUSTER)

 // Printing macros for cluster: Shade Configuration
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER)
 #define emberAfShadeConfigClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER, __VA_ARGS__)
 #define emberAfShadeConfigClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfShadeConfigClusterFlush()
 #define emberAfShadeConfigClusterDebugExec(x)                                                                                      \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER))                                                                  \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfShadeConfigClusterPrintBuffer(buffer, len, withSpace)                                                               \
     emberAfPrintBuffer(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfShadeConfigClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER, (buffer))
 #else
 #define emberAfShadeConfigClusterPrint(...)
 #define emberAfShadeConfigClusterPrintln(...)
 #define emberAfShadeConfigClusterFlush()
 #define emberAfShadeConfigClusterDebugExec(x)
 #define emberAfShadeConfigClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfShadeConfigClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER)

 // Printing macros for cluster: Door Lock
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER)
 #define emberAfDoorLockClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER, __VA_ARGS__)
 #define emberAfDoorLockClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfDoorLockClusterFlush()
 #define emberAfDoorLockClusterDebugExec(x)                                                                                         \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER))                                                                     \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfDoorLockClusterPrintBuffer(buffer, len, withSpace)                                                                  \
     emberAfPrintBuffer(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfDoorLockClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER, (buffer))
 #else
 #define emberAfDoorLockClusterPrint(...)
 #define emberAfDoorLockClusterPrintln(...)
 #define emberAfDoorLockClusterFlush()
 #define emberAfDoorLockClusterDebugExec(x)
 #define emberAfDoorLockClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfDoorLockClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER)

 // Printing macros for cluster: Window Covering
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER)
 #define emberAfWindowCoveringClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER, __VA_ARGS__)
 #define emberAfWindowCoveringClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfWindowCoveringClusterFlush()
 #define emberAfWindowCoveringClusterDebugExec(x)                                                                                   \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER))                                                               \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfWindowCoveringClusterPrintBuffer(buffer, len, withSpace)                                                            \
     emberAfPrintBuffer(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfWindowCoveringClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER, (buffer))
 #else
 #define emberAfWindowCoveringClusterPrint(...)
 #define emberAfWindowCoveringClusterPrintln(...)
 #define emberAfWindowCoveringClusterFlush()
 #define emberAfWindowCoveringClusterDebugExec(x)
 #define emberAfWindowCoveringClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfWindowCoveringClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER)

 // Printing macros for cluster: Barrier Control
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER)
 #define emberAfBarrierControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER, __VA_ARGS__)
 #define emberAfBarrierControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfBarrierControlClusterFlush()
 #define emberAfBarrierControlClusterDebugExec(x)                                                                                   \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER))                                                               \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfBarrierControlClusterPrintBuffer(buffer, len, withSpace)                                                            \
     emberAfPrintBuffer(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfBarrierControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER, (buffer))
 #else
 #define emberAfBarrierControlClusterPrint(...)
 #define emberAfBarrierControlClusterPrintln(...)
 #define emberAfBarrierControlClusterFlush()
 #define emberAfBarrierControlClusterDebugExec(x)
 #define emberAfBarrierControlClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfBarrierControlClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER)

 // Printing macros for cluster: Pump Configuration and Control
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER)
 #define emberAfPumpConfigControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER, __VA_ARGS__)
 #define emberAfPumpConfigControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfPumpConfigControlClusterFlush()
 #define emberAfPumpConfigControlClusterDebugExec(x)                                                                                \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER))                                                           \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfPumpConfigControlClusterPrintBuffer(buffer, len, withSpace)                                                         \
     emberAfPrintBuffer(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfPumpConfigControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER, (buffer))
 #else
 #define emberAfPumpConfigControlClusterPrint(...)
 #define emberAfPumpConfigControlClusterPrintln(...)
 #define emberAfPumpConfigControlClusterFlush()
 #define emberAfPumpConfigControlClusterDebugExec(x)
 #define emberAfPumpConfigControlClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfPumpConfigControlClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER)

 // Printing macros for cluster: Thermostat
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_THERMOSTAT_CLUSTER)
 #define emberAfThermostatClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_THERMOSTAT_CLUSTER, __VA_ARGS__)
 #define emberAfThermostatClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_THERMOSTAT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfThermostatClusterFlush()
 #define emberAfThermostatClusterDebugExec(x)                                                                                       \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_THERMOSTAT_CLUSTER))                                                                    \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfThermostatClusterPrintBuffer(buffer, len, withSpace)                                                                \
     emberAfPrintBuffer(EMBER_AF_PRINT_THERMOSTAT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfThermostatClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_THERMOSTAT_CLUSTER, (buffer))
 #else
 #define emberAfThermostatClusterPrint(...)
 #define emberAfThermostatClusterPrintln(...)
 #define emberAfThermostatClusterFlush()
 #define emberAfThermostatClusterDebugExec(x)
 #define emberAfThermostatClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfThermostatClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_THERMOSTAT_CLUSTER)

 // Printing macros for cluster: Fan Control
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER)
 #define emberAfFanControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER, __VA_ARGS__)
 #define emberAfFanControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfFanControlClusterFlush()
 #define emberAfFanControlClusterDebugExec(x)                                                                                       \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER))                                                                   \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfFanControlClusterPrintBuffer(buffer, len, withSpace)                                                                \
     emberAfPrintBuffer(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfFanControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER, (buffer))
 #else
 #define emberAfFanControlClusterPrint(...)
 #define emberAfFanControlClusterPrintln(...)
 #define emberAfFanControlClusterFlush()
 #define emberAfFanControlClusterDebugExec(x)
 #define emberAfFanControlClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfFanControlClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER)

 // Printing macros for cluster: Dehumidification Control
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER)
 #define emberAfDehumidControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER, __VA_ARGS__)
 #define emberAfDehumidControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfDehumidControlClusterFlush()
 #define emberAfDehumidControlClusterDebugExec(x)                                                                                   \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER))                                                               \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfDehumidControlClusterPrintBuffer(buffer, len, withSpace)                                                            \
     emberAfPrintBuffer(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfDehumidControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER, (buffer))
 #else
 #define emberAfDehumidControlClusterPrint(...)
 #define emberAfDehumidControlClusterPrintln(...)
 #define emberAfDehumidControlClusterFlush()
 #define emberAfDehumidControlClusterDebugExec(x)
 #define emberAfDehumidControlClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfDehumidControlClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER)

 // Printing macros for cluster: Thermostat User Interface Configuration
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER)
 #define emberAfThermostatUiConfigClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER, __VA_ARGS__)
 #define emberAfThermostatUiConfigClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfThermostatUiConfigClusterFlush()
 #define emberAfThermostatUiConfigClusterDebugExec(x)                                                                               \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER))                                                          \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfThermostatUiConfigClusterPrintBuffer(buffer, len, withSpace)                                                        \
     emberAfPrintBuffer(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfThermostatUiConfigClusterPrintString(buffer)                                                                        \
     emberAfPrintString(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER, (buffer))
 #else
 #define emberAfThermostatUiConfigClusterPrint(...)
 #define emberAfThermostatUiConfigClusterPrintln(...)
 #define emberAfThermostatUiConfigClusterFlush()
 #define emberAfThermostatUiConfigClusterDebugExec(x)
 #define emberAfThermostatUiConfigClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfThermostatUiConfigClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER)

 // Printing macros for cluster: Color Control
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER)
 #define emberAfColorControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER, __VA_ARGS__)
 #define emberAfColorControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfColorControlClusterFlush()
 #define emberAfColorControlClusterDebugExec(x)                                                                                     \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER))                                                                 \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfColorControlClusterPrintBuffer(buffer, len, withSpace)                                                              \
     emberAfPrintBuffer(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfColorControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER, (buffer))
 #else
 #define emberAfColorControlClusterPrint(...)
 #define emberAfColorControlClusterPrintln(...)
 #define emberAfColorControlClusterFlush()
 #define emberAfColorControlClusterDebugExec(x)
 #define emberAfColorControlClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfColorControlClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER)

 // Printing macros for cluster: Ballast Configuration
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER)
 #define emberAfBallastConfigurationClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER, __VA_ARGS__)
 #define emberAfBallastConfigurationClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfBallastConfigurationClusterFlush()
 #define emberAfBallastConfigurationClusterDebugExec(x)                                                                             \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER))                                                         \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfBallastConfigurationClusterPrintBuffer(buffer, len, withSpace)                                                      \
     emberAfPrintBuffer(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfBallastConfigurationClusterPrintString(buffer)                                                                      \
     emberAfPrintString(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER, (buffer))
 #else
 #define emberAfBallastConfigurationClusterPrint(...)
 #define emberAfBallastConfigurationClusterPrintln(...)
 #define emberAfBallastConfigurationClusterFlush()
 #define emberAfBallastConfigurationClusterDebugExec(x)
 #define emberAfBallastConfigurationClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfBallastConfigurationClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER)

 // Printing macros for cluster: Illuminance Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER)
 #define emberAfIllumMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfIllumMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfIllumMeasurementClusterFlush()
 #define emberAfIllumMeasurementClusterDebugExec(x)                                                                                 \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER))                                                             \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfIllumMeasurementClusterPrintBuffer(buffer, len, withSpace)                                                          \
     emberAfPrintBuffer(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfIllumMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfIllumMeasurementClusterPrint(...)
 #define emberAfIllumMeasurementClusterPrintln(...)
 #define emberAfIllumMeasurementClusterFlush()
 #define emberAfIllumMeasurementClusterDebugExec(x)
 #define emberAfIllumMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfIllumMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Illuminance Level Sensing
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER)
 #define emberAfIllumLevelSensingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER, __VA_ARGS__)
 #define emberAfIllumLevelSensingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfIllumLevelSensingClusterFlush()
 #define emberAfIllumLevelSensingClusterDebugExec(x)                                                                                \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER))                                                           \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfIllumLevelSensingClusterPrintBuffer(buffer, len, withSpace)                                                         \
     emberAfPrintBuffer(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfIllumLevelSensingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER, (buffer))
 #else
 #define emberAfIllumLevelSensingClusterPrint(...)
 #define emberAfIllumLevelSensingClusterPrintln(...)
 #define emberAfIllumLevelSensingClusterFlush()
 #define emberAfIllumLevelSensingClusterDebugExec(x)
 #define emberAfIllumLevelSensingClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfIllumLevelSensingClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER)

 // Printing macros for cluster: Temperature Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER)
 #define emberAfTempMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfTempMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfTempMeasurementClusterFlush()
 #define emberAfTempMeasurementClusterDebugExec(x)                                                                                  \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER))                                                              \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfTempMeasurementClusterPrintBuffer(buffer, len, withSpace)                                                           \
     emberAfPrintBuffer(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfTempMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfTempMeasurementClusterPrint(...)
 #define emberAfTempMeasurementClusterPrintln(...)
 #define emberAfTempMeasurementClusterFlush()
 #define emberAfTempMeasurementClusterDebugExec(x)
 #define emberAfTempMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfTempMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Pressure Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER)
 #define emberAfPressureMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfPressureMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfPressureMeasurementClusterFlush()
 #define emberAfPressureMeasurementClusterDebugExec(x)                                                                              \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER))                                                          \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfPressureMeasurementClusterPrintBuffer(buffer, len, withSpace)                                                       \
     emberAfPrintBuffer(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfPressureMeasurementClusterPrintString(buffer)                                                                       \
     emberAfPrintString(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfPressureMeasurementClusterPrint(...)
 #define emberAfPressureMeasurementClusterPrintln(...)
 #define emberAfPressureMeasurementClusterFlush()
 #define emberAfPressureMeasurementClusterDebugExec(x)
 #define emberAfPressureMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfPressureMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Flow Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER)
 #define emberAfFlowMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfFlowMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfFlowMeasurementClusterFlush()
 #define emberAfFlowMeasurementClusterDebugExec(x)                                                                                  \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER))                                                              \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfFlowMeasurementClusterPrintBuffer(buffer, len, withSpace)                                                           \
     emberAfPrintBuffer(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfFlowMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfFlowMeasurementClusterPrint(...)
 #define emberAfFlowMeasurementClusterPrintln(...)
 #define emberAfFlowMeasurementClusterFlush()
 #define emberAfFlowMeasurementClusterDebugExec(x)
 #define emberAfFlowMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfFlowMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Relative Humidity Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER)
 #define emberAfRelativeHumidityMeasurementClusterPrint(...)                                                                        \
     emberAfPrint(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfRelativeHumidityMeasurementClusterPrintln(...)                                                                      \
     emberAfPrintln(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfRelativeHumidityMeasurementClusterFlush()
 #define emberAfRelativeHumidityMeasurementClusterDebugExec(x)                                                                      \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER))                                                 \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfRelativeHumidityMeasurementClusterPrintBuffer(buffer, len, withSpace)                                               \
     emberAfPrintBuffer(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfRelativeHumidityMeasurementClusterPrintString(buffer)                                                               \
     emberAfPrintString(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfRelativeHumidityMeasurementClusterPrint(...)
 #define emberAfRelativeHumidityMeasurementClusterPrintln(...)
 #define emberAfRelativeHumidityMeasurementClusterFlush()
 #define emberAfRelativeHumidityMeasurementClusterDebugExec(x)
 #define emberAfRelativeHumidityMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfRelativeHumidityMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Occupancy Sensing
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER)
 #define emberAfOccupancySensingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER, __VA_ARGS__)
 #define emberAfOccupancySensingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfOccupancySensingClusterFlush()
 #define emberAfOccupancySensingClusterDebugExec(x)                                                                                 \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER))                                                             \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfOccupancySensingClusterPrintBuffer(buffer, len, withSpace)                                                          \
     emberAfPrintBuffer(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfOccupancySensingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER, (buffer))
 #else
 #define emberAfOccupancySensingClusterPrint(...)
 #define emberAfOccupancySensingClusterPrintln(...)
 #define emberAfOccupancySensingClusterFlush()
 #define emberAfOccupancySensingClusterDebugExec(x)
 #define emberAfOccupancySensingClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfOccupancySensingClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER)

 // Printing macros for cluster: Carbon Monoxide Concentration Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)
 #define emberAfCarbonMonoxideConcentrationMeasurementClusterPrint(...)                                                             \
     emberAfPrint(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfCarbonMonoxideConcentrationMeasurementClusterPrintln(...)                                                           \
     emberAfPrintln(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfCarbonMonoxideConcentrationMeasurementClusterFlush()
 #define emberAfCarbonMonoxideConcentrationMeasurementClusterDebugExec(x)                                                           \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER))                                     \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfCarbonMonoxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                    \
     emberAfPrintBuffer(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfCarbonMonoxideConcentrationMeasurementClusterPrintString(buffer)                                                    \
     emberAfPrintString(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfCarbonMonoxideConcentrationMeasurementClusterPrint(...)
 #define emberAfCarbonMonoxideConcentrationMeasurementClusterPrintln(...)
 #define emberAfCarbonMonoxideConcentrationMeasurementClusterFlush()
 #define emberAfCarbonMonoxideConcentrationMeasurementClusterDebugExec(x)
 #define emberAfCarbonMonoxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfCarbonMonoxideConcentrationMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Carbon Dioxide Concentration Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)
 #define emberAfCarbonDioxideConcentrationMeasurementClusterPrint(...)                                                              \
     emberAfPrint(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfCarbonDioxideConcentrationMeasurementClusterPrintln(...)                                                            \
     emberAfPrintln(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfCarbonDioxideConcentrationMeasurementClusterFlush()
 #define emberAfCarbonDioxideConcentrationMeasurementClusterDebugExec(x)                                                            \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER))                                      \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfCarbonDioxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                     \
     emberAfPrintBuffer(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfCarbonDioxideConcentrationMeasurementClusterPrintString(buffer)                                                     \
     emberAfPrintString(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfCarbonDioxideConcentrationMeasurementClusterPrint(...)
 #define emberAfCarbonDioxideConcentrationMeasurementClusterPrintln(...)
 #define emberAfCarbonDioxideConcentrationMeasurementClusterFlush()
 #define emberAfCarbonDioxideConcentrationMeasurementClusterDebugExec(x)
 #define emberAfCarbonDioxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfCarbonDioxideConcentrationMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Ethylene Concentration Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER)
 #define emberAfEthyleneConcentrationMeasurementClusterPrint(...)                                                                   \
     emberAfPrint(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfEthyleneConcentrationMeasurementClusterPrintln(...)                                                                 \
     emberAfPrintln(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfEthyleneConcentrationMeasurementClusterFlush()
 #define emberAfEthyleneConcentrationMeasurementClusterDebugExec(x)                                                                 \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER))                                            \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfEthyleneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                          \
     emberAfPrintBuffer(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfEthyleneConcentrationMeasurementClusterPrintString(buffer)                                                          \
     emberAfPrintString(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfEthyleneConcentrationMeasurementClusterPrint(...)
 #define emberAfEthyleneConcentrationMeasurementClusterPrintln(...)
 #define emberAfEthyleneConcentrationMeasurementClusterFlush()
 #define emberAfEthyleneConcentrationMeasurementClusterDebugExec(x)
 #define emberAfEthyleneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfEthyleneConcentrationMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Ethylene Oxide Concentration Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)
 #define emberAfEthyleneOxideConcentrationMeasurementClusterPrint(...)                                                              \
     emberAfPrint(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfEthyleneOxideConcentrationMeasurementClusterPrintln(...)                                                            \
     emberAfPrintln(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfEthyleneOxideConcentrationMeasurementClusterFlush()
 #define emberAfEthyleneOxideConcentrationMeasurementClusterDebugExec(x)                                                            \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER))                                      \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfEthyleneOxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                     \
     emberAfPrintBuffer(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfEthyleneOxideConcentrationMeasurementClusterPrintString(buffer)                                                     \
     emberAfPrintString(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfEthyleneOxideConcentrationMeasurementClusterPrint(...)
 #define emberAfEthyleneOxideConcentrationMeasurementClusterPrintln(...)
 #define emberAfEthyleneOxideConcentrationMeasurementClusterFlush()
 #define emberAfEthyleneOxideConcentrationMeasurementClusterDebugExec(x)
 #define emberAfEthyleneOxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfEthyleneOxideConcentrationMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Hydrogen Concentration Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER)
 #define emberAfHydrogenConcentrationMeasurementClusterPrint(...)                                                                   \
     emberAfPrint(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfHydrogenConcentrationMeasurementClusterPrintln(...)                                                                 \
     emberAfPrintln(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfHydrogenConcentrationMeasurementClusterFlush()
 #define emberAfHydrogenConcentrationMeasurementClusterDebugExec(x)                                                                 \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER))                                            \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfHydrogenConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                          \
     emberAfPrintBuffer(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfHydrogenConcentrationMeasurementClusterPrintString(buffer)                                                          \
     emberAfPrintString(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfHydrogenConcentrationMeasurementClusterPrint(...)
 #define emberAfHydrogenConcentrationMeasurementClusterPrintln(...)
 #define emberAfHydrogenConcentrationMeasurementClusterFlush()
 #define emberAfHydrogenConcentrationMeasurementClusterDebugExec(x)
 #define emberAfHydrogenConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfHydrogenConcentrationMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Hydrogen Sulphide Concentration Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER)
 #define emberAfHydrogenSulphideConcentrationMeasurementClusterPrint(...)                                                           \
     emberAfPrint(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfHydrogenSulphideConcentrationMeasurementClusterPrintln(...)                                                         \
     emberAfPrintln(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfHydrogenSulphideConcentrationMeasurementClusterFlush()
 #define emberAfHydrogenSulphideConcentrationMeasurementClusterDebugExec(x)                                                         \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER))                                   \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfHydrogenSulphideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                  \
     emberAfPrintBuffer(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfHydrogenSulphideConcentrationMeasurementClusterPrintString(buffer)                                                  \
     emberAfPrintString(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfHydrogenSulphideConcentrationMeasurementClusterPrint(...)
 #define emberAfHydrogenSulphideConcentrationMeasurementClusterPrintln(...)
 #define emberAfHydrogenSulphideConcentrationMeasurementClusterFlush()
 #define emberAfHydrogenSulphideConcentrationMeasurementClusterDebugExec(x)
 #define emberAfHydrogenSulphideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfHydrogenSulphideConcentrationMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Nitric Oxide Concentration Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)
 #define emberAfNitricOxideConcentrationMeasurementClusterPrint(...)                                                                \
     emberAfPrint(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfNitricOxideConcentrationMeasurementClusterPrintln(...)                                                              \
     emberAfPrintln(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfNitricOxideConcentrationMeasurementClusterFlush()
 #define emberAfNitricOxideConcentrationMeasurementClusterDebugExec(x)                                                              \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER))                                        \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfNitricOxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                       \
     emberAfPrintBuffer(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfNitricOxideConcentrationMeasurementClusterPrintString(buffer)                                                       \
     emberAfPrintString(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfNitricOxideConcentrationMeasurementClusterPrint(...)
 #define emberAfNitricOxideConcentrationMeasurementClusterPrintln(...)
 #define emberAfNitricOxideConcentrationMeasurementClusterFlush()
 #define emberAfNitricOxideConcentrationMeasurementClusterDebugExec(x)
 #define emberAfNitricOxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfNitricOxideConcentrationMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Nitrogen Dioxide Concentration Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)
 #define emberAfNitrogenDioxideConcentrationMeasurementClusterPrint(...)                                                            \
     emberAfPrint(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfNitrogenDioxideConcentrationMeasurementClusterPrintln(...)                                                          \
     emberAfPrintln(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfNitrogenDioxideConcentrationMeasurementClusterFlush()
 #define emberAfNitrogenDioxideConcentrationMeasurementClusterDebugExec(x)                                                          \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER))                                    \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfNitrogenDioxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                   \
     emberAfPrintBuffer(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfNitrogenDioxideConcentrationMeasurementClusterPrintString(buffer)                                                   \
     emberAfPrintString(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfNitrogenDioxideConcentrationMeasurementClusterPrint(...)
 #define emberAfNitrogenDioxideConcentrationMeasurementClusterPrintln(...)
 #define emberAfNitrogenDioxideConcentrationMeasurementClusterFlush()
 #define emberAfNitrogenDioxideConcentrationMeasurementClusterDebugExec(x)
 #define emberAfNitrogenDioxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfNitrogenDioxideConcentrationMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Oxygen Concentration Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER)
 #define emberAfOxygenConcentrationMeasurementClusterPrint(...)                                                                     \
     emberAfPrint(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfOxygenConcentrationMeasurementClusterPrintln(...)                                                                   \
     emberAfPrintln(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfOxygenConcentrationMeasurementClusterFlush()
 #define emberAfOxygenConcentrationMeasurementClusterDebugExec(x)                                                                   \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER))                                              \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfOxygenConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                            \
     emberAfPrintBuffer(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfOxygenConcentrationMeasurementClusterPrintString(buffer)                                                            \
     emberAfPrintString(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfOxygenConcentrationMeasurementClusterPrint(...)
 #define emberAfOxygenConcentrationMeasurementClusterPrintln(...)
 #define emberAfOxygenConcentrationMeasurementClusterFlush()
 #define emberAfOxygenConcentrationMeasurementClusterDebugExec(x)
 #define emberAfOxygenConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfOxygenConcentrationMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Ozone Concentration Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER)
 #define emberAfOzoneConcentrationMeasurementClusterPrint(...)                                                                      \
     emberAfPrint(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfOzoneConcentrationMeasurementClusterPrintln(...)                                                                    \
     emberAfPrintln(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfOzoneConcentrationMeasurementClusterFlush()
 #define emberAfOzoneConcentrationMeasurementClusterDebugExec(x)                                                                    \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER))                                               \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfOzoneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                             \
     emberAfPrintBuffer(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfOzoneConcentrationMeasurementClusterPrintString(buffer)                                                             \
     emberAfPrintString(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfOzoneConcentrationMeasurementClusterPrint(...)
 #define emberAfOzoneConcentrationMeasurementClusterPrintln(...)
 #define emberAfOzoneConcentrationMeasurementClusterFlush()
 #define emberAfOzoneConcentrationMeasurementClusterDebugExec(x)
 #define emberAfOzoneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfOzoneConcentrationMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Sulfur Dioxide Concentration Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)
 #define emberAfSulfurDioxideConcentrationMeasurementClusterPrint(...)                                                              \
     emberAfPrint(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfSulfurDioxideConcentrationMeasurementClusterPrintln(...)                                                            \
     emberAfPrintln(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfSulfurDioxideConcentrationMeasurementClusterFlush()
 #define emberAfSulfurDioxideConcentrationMeasurementClusterDebugExec(x)                                                            \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER))                                      \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfSulfurDioxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                     \
     emberAfPrintBuffer(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfSulfurDioxideConcentrationMeasurementClusterPrintString(buffer)                                                     \
     emberAfPrintString(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfSulfurDioxideConcentrationMeasurementClusterPrint(...)
 #define emberAfSulfurDioxideConcentrationMeasurementClusterPrintln(...)
 #define emberAfSulfurDioxideConcentrationMeasurementClusterFlush()
 #define emberAfSulfurDioxideConcentrationMeasurementClusterDebugExec(x)
 #define emberAfSulfurDioxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfSulfurDioxideConcentrationMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Dissolved Oxygen Concentration Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER)
 #define emberAfDissolvedOxygenConcentrationMeasurementClusterPrint(...)                                                            \
     emberAfPrint(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfDissolvedOxygenConcentrationMeasurementClusterPrintln(...)                                                          \
     emberAfPrintln(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfDissolvedOxygenConcentrationMeasurementClusterFlush()
 #define emberAfDissolvedOxygenConcentrationMeasurementClusterDebugExec(x)                                                          \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER))                                    \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfDissolvedOxygenConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                   \
     emberAfPrintBuffer(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfDissolvedOxygenConcentrationMeasurementClusterPrintString(buffer)                                                   \
     emberAfPrintString(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfDissolvedOxygenConcentrationMeasurementClusterPrint(...)
 #define emberAfDissolvedOxygenConcentrationMeasurementClusterPrintln(...)
 #define emberAfDissolvedOxygenConcentrationMeasurementClusterFlush()
 #define emberAfDissolvedOxygenConcentrationMeasurementClusterDebugExec(x)
 #define emberAfDissolvedOxygenConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfDissolvedOxygenConcentrationMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Bromate Concentration Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER)
 #define emberAfBromateConcentrationMeasurementClusterPrint(...)                                                                    \
     emberAfPrint(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfBromateConcentrationMeasurementClusterPrintln(...)                                                                  \
     emberAfPrintln(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfBromateConcentrationMeasurementClusterFlush()
 #define emberAfBromateConcentrationMeasurementClusterDebugExec(x)                                                                  \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER))                                             \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfBromateConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                           \
     emberAfPrintBuffer(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfBromateConcentrationMeasurementClusterPrintString(buffer)                                                           \
     emberAfPrintString(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfBromateConcentrationMeasurementClusterPrint(...)
 #define emberAfBromateConcentrationMeasurementClusterPrintln(...)
 #define emberAfBromateConcentrationMeasurementClusterFlush()
 #define emberAfBromateConcentrationMeasurementClusterDebugExec(x)
 #define emberAfBromateConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfBromateConcentrationMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Chloramines Concentration Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER)
 #define emberAfChloraminesConcentrationMeasurementClusterPrint(...)                                                                \
     emberAfPrint(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfChloraminesConcentrationMeasurementClusterPrintln(...)                                                              \
     emberAfPrintln(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfChloraminesConcentrationMeasurementClusterFlush()
 #define emberAfChloraminesConcentrationMeasurementClusterDebugExec(x)                                                              \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER))                                         \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfChloraminesConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                       \
     emberAfPrintBuffer(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfChloraminesConcentrationMeasurementClusterPrintString(buffer)                                                       \
     emberAfPrintString(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfChloraminesConcentrationMeasurementClusterPrint(...)
 #define emberAfChloraminesConcentrationMeasurementClusterPrintln(...)
 #define emberAfChloraminesConcentrationMeasurementClusterFlush()
 #define emberAfChloraminesConcentrationMeasurementClusterDebugExec(x)
 #define emberAfChloraminesConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfChloraminesConcentrationMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Chlorine Concentration Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER)
 #define emberAfChlorineConcentrationMeasurementClusterPrint(...)                                                                   \
     emberAfPrint(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfChlorineConcentrationMeasurementClusterPrintln(...)                                                                 \
     emberAfPrintln(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfChlorineConcentrationMeasurementClusterFlush()
 #define emberAfChlorineConcentrationMeasurementClusterDebugExec(x)                                                                 \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER))                                            \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfChlorineConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                          \
     emberAfPrintBuffer(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfChlorineConcentrationMeasurementClusterPrintString(buffer)                                                          \
     emberAfPrintString(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfChlorineConcentrationMeasurementClusterPrint(...)
 #define emberAfChlorineConcentrationMeasurementClusterPrintln(...)
 #define emberAfChlorineConcentrationMeasurementClusterFlush()
 #define emberAfChlorineConcentrationMeasurementClusterDebugExec(x)
 #define emberAfChlorineConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfChlorineConcentrationMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Fecal coliform and E. Coli Concentration Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER)
 #define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrint(...)                                                      \
     emberAfPrint(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrintln(...)                                                    \
     emberAfPrintln(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfFecalColiformAndEColiConcentrationMeasurementClusterFlush()
 #define emberAfFecalColiformAndEColiConcentrationMeasurementClusterDebugExec(x)                                                    \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER))                           \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                             \
     emberAfPrintBuffer(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrintString(buffer)                                             \
     emberAfPrintString(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrint(...)
 #define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrintln(...)
 #define emberAfFecalColiformAndEColiConcentrationMeasurementClusterFlush()
 #define emberAfFecalColiformAndEColiConcentrationMeasurementClusterDebugExec(x)
 #define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Fluoride Concentration Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER)
 #define emberAfFluorideConcentrationMeasurementClusterPrint(...)                                                                   \
     emberAfPrint(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfFluorideConcentrationMeasurementClusterPrintln(...)                                                                 \
     emberAfPrintln(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfFluorideConcentrationMeasurementClusterFlush()
 #define emberAfFluorideConcentrationMeasurementClusterDebugExec(x)                                                                 \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER))                                            \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfFluorideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                          \
     emberAfPrintBuffer(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfFluorideConcentrationMeasurementClusterPrintString(buffer)                                                          \
     emberAfPrintString(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfFluorideConcentrationMeasurementClusterPrint(...)
 #define emberAfFluorideConcentrationMeasurementClusterPrintln(...)
 #define emberAfFluorideConcentrationMeasurementClusterFlush()
 #define emberAfFluorideConcentrationMeasurementClusterDebugExec(x)
 #define emberAfFluorideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfFluorideConcentrationMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Haloacetic Acids Concentration Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER)
 #define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrint(...)                                                            \
     emberAfPrint(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrintln(...)                                                          \
     emberAfPrintln(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfHaloaceticAcidsConcentrationMeasurementClusterFlush()
 #define emberAfHaloaceticAcidsConcentrationMeasurementClusterDebugExec(x)                                                          \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER))                                    \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                   \
     emberAfPrintBuffer(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrintString(buffer)                                                   \
     emberAfPrintString(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrint(...)
 #define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrintln(...)
 #define emberAfHaloaceticAcidsConcentrationMeasurementClusterFlush()
 #define emberAfHaloaceticAcidsConcentrationMeasurementClusterDebugExec(x)
 #define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Total Trihalomethanes Concentration Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER)
 #define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrint(...)                                                       \
     emberAfPrint(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrintln(...)                                                     \
     emberAfPrintln(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfTotalTrihalomethanesConcentrationMeasurementClusterFlush()
 #define emberAfTotalTrihalomethanesConcentrationMeasurementClusterDebugExec(x)                                                     \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER))                               \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                              \
     emberAfPrintBuffer(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrintString(buffer)                                              \
     emberAfPrintString(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrint(...)
 #define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrintln(...)
 #define emberAfTotalTrihalomethanesConcentrationMeasurementClusterFlush()
 #define emberAfTotalTrihalomethanesConcentrationMeasurementClusterDebugExec(x)
 #define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Total Coliform Bacteria Concentration Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER)
 #define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrint(...)                                                      \
     emberAfPrint(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrintln(...)                                                    \
     emberAfPrintln(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfTotalColiformBacteriaConcentrationMeasurementClusterFlush()
 #define emberAfTotalColiformBacteriaConcentrationMeasurementClusterDebugExec(x)                                                    \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER))                             \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                             \
     emberAfPrintBuffer(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrintString(buffer)                                             \
     emberAfPrintString(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrint(...)
 #define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrintln(...)
 #define emberAfTotalColiformBacteriaConcentrationMeasurementClusterFlush()
 #define emberAfTotalColiformBacteriaConcentrationMeasurementClusterDebugExec(x)
 #define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Turbidity Concentration Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER)
 #define emberAfTurbidityConcentrationMeasurementClusterPrint(...)                                                                  \
     emberAfPrint(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfTurbidityConcentrationMeasurementClusterPrintln(...)                                                                \
     emberAfPrintln(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfTurbidityConcentrationMeasurementClusterFlush()
 #define emberAfTurbidityConcentrationMeasurementClusterDebugExec(x)                                                                \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER))                                           \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfTurbidityConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                         \
     emberAfPrintBuffer(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfTurbidityConcentrationMeasurementClusterPrintString(buffer)                                                         \
     emberAfPrintString(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfTurbidityConcentrationMeasurementClusterPrint(...)
 #define emberAfTurbidityConcentrationMeasurementClusterPrintln(...)
 #define emberAfTurbidityConcentrationMeasurementClusterFlush()
 #define emberAfTurbidityConcentrationMeasurementClusterDebugExec(x)
 #define emberAfTurbidityConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfTurbidityConcentrationMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Copper Concentration Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER)
 #define emberAfCopperConcentrationMeasurementClusterPrint(...)                                                                     \
     emberAfPrint(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfCopperConcentrationMeasurementClusterPrintln(...)                                                                   \
     emberAfPrintln(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfCopperConcentrationMeasurementClusterFlush()
 #define emberAfCopperConcentrationMeasurementClusterDebugExec(x)                                                                   \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER))                                              \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfCopperConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                            \
     emberAfPrintBuffer(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfCopperConcentrationMeasurementClusterPrintString(buffer)                                                            \
     emberAfPrintString(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfCopperConcentrationMeasurementClusterPrint(...)
 #define emberAfCopperConcentrationMeasurementClusterPrintln(...)
 #define emberAfCopperConcentrationMeasurementClusterFlush()
 #define emberAfCopperConcentrationMeasurementClusterDebugExec(x)
 #define emberAfCopperConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfCopperConcentrationMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Lead Concentration Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER)
 #define emberAfLeadConcentrationMeasurementClusterPrint(...)                                                                       \
     emberAfPrint(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfLeadConcentrationMeasurementClusterPrintln(...)                                                                     \
     emberAfPrintln(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfLeadConcentrationMeasurementClusterFlush()
 #define emberAfLeadConcentrationMeasurementClusterDebugExec(x)                                                                     \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER))                                                \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfLeadConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                              \
     emberAfPrintBuffer(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfLeadConcentrationMeasurementClusterPrintString(buffer)                                                              \
     emberAfPrintString(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfLeadConcentrationMeasurementClusterPrint(...)
 #define emberAfLeadConcentrationMeasurementClusterPrintln(...)
 #define emberAfLeadConcentrationMeasurementClusterFlush()
 #define emberAfLeadConcentrationMeasurementClusterDebugExec(x)
 #define emberAfLeadConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfLeadConcentrationMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Manganese Concentration Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER)
 #define emberAfManganeseConcentrationMeasurementClusterPrint(...)                                                                  \
     emberAfPrint(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfManganeseConcentrationMeasurementClusterPrintln(...)                                                                \
     emberAfPrintln(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfManganeseConcentrationMeasurementClusterFlush()
 #define emberAfManganeseConcentrationMeasurementClusterDebugExec(x)                                                                \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER))                                           \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfManganeseConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                         \
     emberAfPrintBuffer(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfManganeseConcentrationMeasurementClusterPrintString(buffer)                                                         \
     emberAfPrintString(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfManganeseConcentrationMeasurementClusterPrint(...)
 #define emberAfManganeseConcentrationMeasurementClusterPrintln(...)
 #define emberAfManganeseConcentrationMeasurementClusterFlush()
 #define emberAfManganeseConcentrationMeasurementClusterDebugExec(x)
 #define emberAfManganeseConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfManganeseConcentrationMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Sulfate Concentration Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER)
 #define emberAfSulfateConcentrationMeasurementClusterPrint(...)                                                                    \
     emberAfPrint(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfSulfateConcentrationMeasurementClusterPrintln(...)                                                                  \
     emberAfPrintln(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfSulfateConcentrationMeasurementClusterFlush()
 #define emberAfSulfateConcentrationMeasurementClusterDebugExec(x)                                                                  \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER))                                             \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfSulfateConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                           \
     emberAfPrintBuffer(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfSulfateConcentrationMeasurementClusterPrintString(buffer)                                                           \
     emberAfPrintString(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfSulfateConcentrationMeasurementClusterPrint(...)
 #define emberAfSulfateConcentrationMeasurementClusterPrintln(...)
 #define emberAfSulfateConcentrationMeasurementClusterFlush()
 #define emberAfSulfateConcentrationMeasurementClusterDebugExec(x)
 #define emberAfSulfateConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfSulfateConcentrationMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Bromodichloromethane Concentration Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER)
 #define emberAfBromodichloromethaneConcentrationMeasurementClusterPrint(...)                                                       \
     emberAfPrint(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfBromodichloromethaneConcentrationMeasurementClusterPrintln(...)                                                     \
     emberAfPrintln(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfBromodichloromethaneConcentrationMeasurementClusterFlush()
 #define emberAfBromodichloromethaneConcentrationMeasurementClusterDebugExec(x)                                                     \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER))                                \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfBromodichloromethaneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                              \
     emberAfPrintBuffer(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfBromodichloromethaneConcentrationMeasurementClusterPrintString(buffer)                                              \
     emberAfPrintString(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfBromodichloromethaneConcentrationMeasurementClusterPrint(...)
 #define emberAfBromodichloromethaneConcentrationMeasurementClusterPrintln(...)
 #define emberAfBromodichloromethaneConcentrationMeasurementClusterFlush()
 #define emberAfBromodichloromethaneConcentrationMeasurementClusterDebugExec(x)
 #define emberAfBromodichloromethaneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfBromodichloromethaneConcentrationMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Bromoform Concentration Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER)
 #define emberAfBromoformConcentrationMeasurementClusterPrint(...)                                                                  \
     emberAfPrint(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfBromoformConcentrationMeasurementClusterPrintln(...)                                                                \
     emberAfPrintln(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfBromoformConcentrationMeasurementClusterFlush()
 #define emberAfBromoformConcentrationMeasurementClusterDebugExec(x)                                                                \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER))                                           \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfBromoformConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                         \
     emberAfPrintBuffer(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfBromoformConcentrationMeasurementClusterPrintString(buffer)                                                         \
     emberAfPrintString(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfBromoformConcentrationMeasurementClusterPrint(...)
 #define emberAfBromoformConcentrationMeasurementClusterPrintln(...)
 #define emberAfBromoformConcentrationMeasurementClusterFlush()
 #define emberAfBromoformConcentrationMeasurementClusterDebugExec(x)
 #define emberAfBromoformConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfBromoformConcentrationMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Chlorodibromomethane Concentration Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER)
 #define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrint(...)                                                       \
     emberAfPrint(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrintln(...)                                                     \
     emberAfPrintln(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfChlorodibromomethaneConcentrationMeasurementClusterFlush()
 #define emberAfChlorodibromomethaneConcentrationMeasurementClusterDebugExec(x)                                                     \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER))                                \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                              \
     emberAfPrintBuffer(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrintString(buffer)                                              \
     emberAfPrintString(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrint(...)
 #define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrintln(...)
 #define emberAfChlorodibromomethaneConcentrationMeasurementClusterFlush()
 #define emberAfChlorodibromomethaneConcentrationMeasurementClusterDebugExec(x)
 #define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Chloroform Concentration Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER)
 #define emberAfChloroformConcentrationMeasurementClusterPrint(...)                                                                 \
     emberAfPrint(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfChloroformConcentrationMeasurementClusterPrintln(...)                                                               \
     emberAfPrintln(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfChloroformConcentrationMeasurementClusterFlush()
 #define emberAfChloroformConcentrationMeasurementClusterDebugExec(x)                                                               \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER))                                          \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfChloroformConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                        \
     emberAfPrintBuffer(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfChloroformConcentrationMeasurementClusterPrintString(buffer)                                                        \
     emberAfPrintString(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfChloroformConcentrationMeasurementClusterPrint(...)
 #define emberAfChloroformConcentrationMeasurementClusterPrintln(...)
 #define emberAfChloroformConcentrationMeasurementClusterFlush()
 #define emberAfChloroformConcentrationMeasurementClusterDebugExec(x)
 #define emberAfChloroformConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfChloroformConcentrationMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Sodium Concentration Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER)
 #define emberAfSodiumConcentrationMeasurementClusterPrint(...)                                                                     \
     emberAfPrint(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfSodiumConcentrationMeasurementClusterPrintln(...)                                                                   \
     emberAfPrintln(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfSodiumConcentrationMeasurementClusterFlush()
 #define emberAfSodiumConcentrationMeasurementClusterDebugExec(x)                                                                   \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER))                                              \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfSodiumConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                            \
     emberAfPrintBuffer(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfSodiumConcentrationMeasurementClusterPrintString(buffer)                                                            \
     emberAfPrintString(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfSodiumConcentrationMeasurementClusterPrint(...)
 #define emberAfSodiumConcentrationMeasurementClusterPrintln(...)
 #define emberAfSodiumConcentrationMeasurementClusterFlush()
 #define emberAfSodiumConcentrationMeasurementClusterDebugExec(x)
 #define emberAfSodiumConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfSodiumConcentrationMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: IAS Zone
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IAS_ZONE_CLUSTER)
 #define emberAfIasZoneClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_IAS_ZONE_CLUSTER, __VA_ARGS__)
 #define emberAfIasZoneClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_IAS_ZONE_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfIasZoneClusterFlush()
 #define emberAfIasZoneClusterDebugExec(x)                                                                                          \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_IAS_ZONE_CLUSTER))                                                                      \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfIasZoneClusterPrintBuffer(buffer, len, withSpace)                                                                   \
     emberAfPrintBuffer(EMBER_AF_PRINT_IAS_ZONE_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfIasZoneClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_IAS_ZONE_CLUSTER, (buffer))
 #else
 #define emberAfIasZoneClusterPrint(...)
 #define emberAfIasZoneClusterPrintln(...)
 #define emberAfIasZoneClusterFlush()
 #define emberAfIasZoneClusterDebugExec(x)
 #define emberAfIasZoneClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfIasZoneClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IAS_ZONE_CLUSTER)

 // Printing macros for cluster: IAS ACE
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IAS_ACE_CLUSTER)
 #define emberAfIasAceClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_IAS_ACE_CLUSTER, __VA_ARGS__)
 #define emberAfIasAceClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_IAS_ACE_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfIasAceClusterFlush()
 #define emberAfIasAceClusterDebugExec(x)                                                                                           \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_IAS_ACE_CLUSTER))                                                                       \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfIasAceClusterPrintBuffer(buffer, len, withSpace)                                                                    \
     emberAfPrintBuffer(EMBER_AF_PRINT_IAS_ACE_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfIasAceClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_IAS_ACE_CLUSTER, (buffer))
 #else
 #define emberAfIasAceClusterPrint(...)
 #define emberAfIasAceClusterPrintln(...)
 #define emberAfIasAceClusterFlush()
 #define emberAfIasAceClusterDebugExec(x)
 #define emberAfIasAceClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfIasAceClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IAS_ACE_CLUSTER)

 // Printing macros for cluster: IAS WD
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IAS_WD_CLUSTER)
 #define emberAfIasWdClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_IAS_WD_CLUSTER, __VA_ARGS__)
 #define emberAfIasWdClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_IAS_WD_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfIasWdClusterFlush()
 #define emberAfIasWdClusterDebugExec(x)                                                                                            \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_IAS_WD_CLUSTER))                                                                        \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfIasWdClusterPrintBuffer(buffer, len, withSpace)                                                                     \
     emberAfPrintBuffer(EMBER_AF_PRINT_IAS_WD_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfIasWdClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_IAS_WD_CLUSTER, (buffer))
 #else
 #define emberAfIasWdClusterPrint(...)
 #define emberAfIasWdClusterPrintln(...)
 #define emberAfIasWdClusterFlush()
 #define emberAfIasWdClusterDebugExec(x)
 #define emberAfIasWdClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfIasWdClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IAS_WD_CLUSTER)

 // Printing macros for cluster: Generic Tunnel
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER)
 #define emberAfGenericTunnelClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER, __VA_ARGS__)
 #define emberAfGenericTunnelClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfGenericTunnelClusterFlush()
 #define emberAfGenericTunnelClusterDebugExec(x)                                                                                    \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER))                                                                \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfGenericTunnelClusterPrintBuffer(buffer, len, withSpace)                                                             \
     emberAfPrintBuffer(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfGenericTunnelClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER, (buffer))
 #else
 #define emberAfGenericTunnelClusterPrint(...)
 #define emberAfGenericTunnelClusterPrintln(...)
 #define emberAfGenericTunnelClusterFlush()
 #define emberAfGenericTunnelClusterDebugExec(x)
 #define emberAfGenericTunnelClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfGenericTunnelClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER)

 // Printing macros for cluster: BACnet Protocol Tunnel
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER)
 #define emberAfBacnetProtocolTunnelClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER, __VA_ARGS__)
 #define emberAfBacnetProtocolTunnelClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfBacnetProtocolTunnelClusterFlush()
 #define emberAfBacnetProtocolTunnelClusterDebugExec(x)                                                                             \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER))                                                        \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfBacnetProtocolTunnelClusterPrintBuffer(buffer, len, withSpace)                                                      \
     emberAfPrintBuffer(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfBacnetProtocolTunnelClusterPrintString(buffer)                                                                      \
     emberAfPrintString(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER, (buffer))
 #else
 #define emberAfBacnetProtocolTunnelClusterPrint(...)
 #define emberAfBacnetProtocolTunnelClusterPrintln(...)
 #define emberAfBacnetProtocolTunnelClusterFlush()
 #define emberAfBacnetProtocolTunnelClusterDebugExec(x)
 #define emberAfBacnetProtocolTunnelClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfBacnetProtocolTunnelClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER)

 // Printing macros for cluster: 11073 Protocol Tunnel
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER)
 #define emberAf11073ProtocolTunnelClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER, __VA_ARGS__)
 #define emberAf11073ProtocolTunnelClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAf11073ProtocolTunnelClusterFlush()
 #define emberAf11073ProtocolTunnelClusterDebugExec(x)                                                                              \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER))                                                         \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAf11073ProtocolTunnelClusterPrintBuffer(buffer, len, withSpace)                                                       \
     emberAfPrintBuffer(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER, (buffer), (len), (withSpace))
 #define emberAf11073ProtocolTunnelClusterPrintString(buffer)                                                                       \
     emberAfPrintString(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER, (buffer))
 #else
 #define emberAf11073ProtocolTunnelClusterPrint(...)
 #define emberAf11073ProtocolTunnelClusterPrintln(...)
 #define emberAf11073ProtocolTunnelClusterFlush()
 #define emberAf11073ProtocolTunnelClusterDebugExec(x)
 #define emberAf11073ProtocolTunnelClusterPrintBuffer(buffer, len, withSpace)
 #define emberAf11073ProtocolTunnelClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER)

 // Printing macros for cluster: ISO 7816 Protocol Tunnel
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER)
 #define emberAfIso7816ProtocolTunnelClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER, __VA_ARGS__)
 #define emberAfIso7816ProtocolTunnelClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfIso7816ProtocolTunnelClusterFlush()
 #define emberAfIso7816ProtocolTunnelClusterDebugExec(x)                                                                            \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER))                                                       \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfIso7816ProtocolTunnelClusterPrintBuffer(buffer, len, withSpace)                                                     \
     emberAfPrintBuffer(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfIso7816ProtocolTunnelClusterPrintString(buffer)                                                                     \
     emberAfPrintString(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER, (buffer))
 #else
 #define emberAfIso7816ProtocolTunnelClusterPrint(...)
 #define emberAfIso7816ProtocolTunnelClusterPrintln(...)
 #define emberAfIso7816ProtocolTunnelClusterFlush()
 #define emberAfIso7816ProtocolTunnelClusterDebugExec(x)
 #define emberAfIso7816ProtocolTunnelClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfIso7816ProtocolTunnelClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER)

 // Printing macros for cluster: Price
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PRICE_CLUSTER)
 #define emberAfPriceClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_PRICE_CLUSTER, __VA_ARGS__)
 #define emberAfPriceClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PRICE_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfPriceClusterFlush()
 #define emberAfPriceClusterDebugExec(x)                                                                                            \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_PRICE_CLUSTER))                                                                         \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfPriceClusterPrintBuffer(buffer, len, withSpace)                                                                     \
     emberAfPrintBuffer(EMBER_AF_PRINT_PRICE_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfPriceClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_PRICE_CLUSTER, (buffer))
 #else
 #define emberAfPriceClusterPrint(...)
 #define emberAfPriceClusterPrintln(...)
 #define emberAfPriceClusterFlush()
 #define emberAfPriceClusterDebugExec(x)
 #define emberAfPriceClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfPriceClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PRICE_CLUSTER)

 // Printing macros for cluster: Demand Response and Load Control
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER)
 #define emberAfDemandResponseLoadControlClusterPrint(...)                                                                          \
     emberAfPrint(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER, __VA_ARGS__)
 #define emberAfDemandResponseLoadControlClusterPrintln(...)                                                                        \
     emberAfPrintln(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfDemandResponseLoadControlClusterFlush()
 #define emberAfDemandResponseLoadControlClusterDebugExec(x)                                                                        \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER))                                                  \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfDemandResponseLoadControlClusterPrintBuffer(buffer, len, withSpace)                                                 \
     emberAfPrintBuffer(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfDemandResponseLoadControlClusterPrintString(buffer)                                                                 \
     emberAfPrintString(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER, (buffer))
 #else
 #define emberAfDemandResponseLoadControlClusterPrint(...)
 #define emberAfDemandResponseLoadControlClusterPrintln(...)
 #define emberAfDemandResponseLoadControlClusterFlush()
 #define emberAfDemandResponseLoadControlClusterDebugExec(x)
 #define emberAfDemandResponseLoadControlClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfDemandResponseLoadControlClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER)

 // Printing macros for cluster: Simple Metering
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER)
 #define emberAfSimpleMeteringClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER, __VA_ARGS__)
 #define emberAfSimpleMeteringClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfSimpleMeteringClusterFlush()
 #define emberAfSimpleMeteringClusterDebugExec(x)                                                                                   \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER))                                                               \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfSimpleMeteringClusterPrintBuffer(buffer, len, withSpace)                                                            \
     emberAfPrintBuffer(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfSimpleMeteringClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER, (buffer))
 #else
 #define emberAfSimpleMeteringClusterPrint(...)
 #define emberAfSimpleMeteringClusterPrintln(...)
 #define emberAfSimpleMeteringClusterFlush()
 #define emberAfSimpleMeteringClusterDebugExec(x)
 #define emberAfSimpleMeteringClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfSimpleMeteringClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER)

 // Printing macros for cluster: Messaging
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MESSAGING_CLUSTER)
 #define emberAfMessagingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_MESSAGING_CLUSTER, __VA_ARGS__)
 #define emberAfMessagingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_MESSAGING_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfMessagingClusterFlush()
 #define emberAfMessagingClusterDebugExec(x)                                                                                        \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_MESSAGING_CLUSTER))                                                                     \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfMessagingClusterPrintBuffer(buffer, len, withSpace)                                                                 \
     emberAfPrintBuffer(EMBER_AF_PRINT_MESSAGING_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfMessagingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_MESSAGING_CLUSTER, (buffer))
 #else
 #define emberAfMessagingClusterPrint(...)
 #define emberAfMessagingClusterPrintln(...)
 #define emberAfMessagingClusterFlush()
 #define emberAfMessagingClusterDebugExec(x)
 #define emberAfMessagingClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfMessagingClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MESSAGING_CLUSTER)

 // Printing macros for cluster: Tunneling
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TUNNELING_CLUSTER)
 #define emberAfTunnelingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_TUNNELING_CLUSTER, __VA_ARGS__)
 #define emberAfTunnelingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_TUNNELING_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfTunnelingClusterFlush()
 #define emberAfTunnelingClusterDebugExec(x)                                                                                        \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_TUNNELING_CLUSTER))                                                                     \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfTunnelingClusterPrintBuffer(buffer, len, withSpace)                                                                 \
     emberAfPrintBuffer(EMBER_AF_PRINT_TUNNELING_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfTunnelingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_TUNNELING_CLUSTER, (buffer))
 #else
 #define emberAfTunnelingClusterPrint(...)
 #define emberAfTunnelingClusterPrintln(...)
 #define emberAfTunnelingClusterFlush()
 #define emberAfTunnelingClusterDebugExec(x)
 #define emberAfTunnelingClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfTunnelingClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TUNNELING_CLUSTER)

 // Printing macros for cluster: Prepayment
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PREPAYMENT_CLUSTER)
 #define emberAfPrepaymentClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_PREPAYMENT_CLUSTER, __VA_ARGS__)
 #define emberAfPrepaymentClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PREPAYMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfPrepaymentClusterFlush()
 #define emberAfPrepaymentClusterDebugExec(x)                                                                                       \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_PREPAYMENT_CLUSTER))                                                                    \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfPrepaymentClusterPrintBuffer(buffer, len, withSpace)                                                                \
     emberAfPrintBuffer(EMBER_AF_PRINT_PREPAYMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfPrepaymentClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_PREPAYMENT_CLUSTER, (buffer))
 #else
 #define emberAfPrepaymentClusterPrint(...)
 #define emberAfPrepaymentClusterPrintln(...)
 #define emberAfPrepaymentClusterFlush()
 #define emberAfPrepaymentClusterDebugExec(x)
 #define emberAfPrepaymentClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfPrepaymentClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PREPAYMENT_CLUSTER)

 // Printing macros for cluster: Energy Management
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER)
 #define emberAfEnergyManagementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER, __VA_ARGS__)
 #define emberAfEnergyManagementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfEnergyManagementClusterFlush()
 #define emberAfEnergyManagementClusterDebugExec(x)                                                                                 \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER))                                                             \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfEnergyManagementClusterPrintBuffer(buffer, len, withSpace)                                                          \
     emberAfPrintBuffer(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfEnergyManagementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER, (buffer))
 #else
 #define emberAfEnergyManagementClusterPrint(...)
 #define emberAfEnergyManagementClusterPrintln(...)
 #define emberAfEnergyManagementClusterFlush()
 #define emberAfEnergyManagementClusterDebugExec(x)
 #define emberAfEnergyManagementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfEnergyManagementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER)

 // Printing macros for cluster: Calendar
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CALENDAR_CLUSTER)
 #define emberAfCalendarClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_CALENDAR_CLUSTER, __VA_ARGS__)
 #define emberAfCalendarClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_CALENDAR_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfCalendarClusterFlush()
 #define emberAfCalendarClusterDebugExec(x)                                                                                         \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_CALENDAR_CLUSTER))                                                                      \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfCalendarClusterPrintBuffer(buffer, len, withSpace)                                                                  \
     emberAfPrintBuffer(EMBER_AF_PRINT_CALENDAR_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfCalendarClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CALENDAR_CLUSTER, (buffer))
 #else
 #define emberAfCalendarClusterPrint(...)
 #define emberAfCalendarClusterPrintln(...)
 #define emberAfCalendarClusterFlush()
 #define emberAfCalendarClusterDebugExec(x)
 #define emberAfCalendarClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfCalendarClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CALENDAR_CLUSTER)

 // Printing macros for cluster: Device Management
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER)
 #define emberAfDeviceManagementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER, __VA_ARGS__)
 #define emberAfDeviceManagementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfDeviceManagementClusterFlush()
 #define emberAfDeviceManagementClusterDebugExec(x)                                                                                 \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER))                                                             \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfDeviceManagementClusterPrintBuffer(buffer, len, withSpace)                                                          \
     emberAfPrintBuffer(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfDeviceManagementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER, (buffer))
 #else
 #define emberAfDeviceManagementClusterPrint(...)
 #define emberAfDeviceManagementClusterPrintln(...)
 #define emberAfDeviceManagementClusterFlush()
 #define emberAfDeviceManagementClusterDebugExec(x)
 #define emberAfDeviceManagementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfDeviceManagementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER)

 // Printing macros for cluster: Events
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_EVENTS_CLUSTER)
 #define emberAfEventsClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_EVENTS_CLUSTER, __VA_ARGS__)
 #define emberAfEventsClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_EVENTS_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfEventsClusterFlush()
 #define emberAfEventsClusterDebugExec(x)                                                                                           \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_EVENTS_CLUSTER))                                                                        \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfEventsClusterPrintBuffer(buffer, len, withSpace)                                                                    \
     emberAfPrintBuffer(EMBER_AF_PRINT_EVENTS_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfEventsClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_EVENTS_CLUSTER, (buffer))
 #else
 #define emberAfEventsClusterPrint(...)
 #define emberAfEventsClusterPrintln(...)
 #define emberAfEventsClusterFlush()
 #define emberAfEventsClusterDebugExec(x)
 #define emberAfEventsClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfEventsClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_EVENTS_CLUSTER)

 // Printing macros for cluster: MDU Pairing
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER)
 #define emberAfMduPairingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER, __VA_ARGS__)
 #define emberAfMduPairingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfMduPairingClusterFlush()
 #define emberAfMduPairingClusterDebugExec(x)                                                                                       \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER))                                                                   \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfMduPairingClusterPrintBuffer(buffer, len, withSpace)                                                                \
     emberAfPrintBuffer(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfMduPairingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER, (buffer))
 #else
 #define emberAfMduPairingClusterPrint(...)
 #define emberAfMduPairingClusterPrintln(...)
 #define emberAfMduPairingClusterFlush()
 #define emberAfMduPairingClusterDebugExec(x)
 #define emberAfMduPairingClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfMduPairingClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER)

 // Printing macros for cluster: Sub-GHz
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SUB_GHZ_CLUSTER)
 #define emberAfSubGhzClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SUB_GHZ_CLUSTER, __VA_ARGS__)
 #define emberAfSubGhzClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SUB_GHZ_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfSubGhzClusterFlush()
 #define emberAfSubGhzClusterDebugExec(x)                                                                                           \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_SUB_GHZ_CLUSTER))                                                                       \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfSubGhzClusterPrintBuffer(buffer, len, withSpace)                                                                    \
     emberAfPrintBuffer(EMBER_AF_PRINT_SUB_GHZ_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfSubGhzClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SUB_GHZ_CLUSTER, (buffer))
 #else
 #define emberAfSubGhzClusterPrint(...)
 #define emberAfSubGhzClusterPrintln(...)
 #define emberAfSubGhzClusterFlush()
 #define emberAfSubGhzClusterDebugExec(x)
 #define emberAfSubGhzClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfSubGhzClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SUB_GHZ_CLUSTER)

 // Printing macros for cluster: Key Establishment
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER)
 #define emberAfKeyEstablishmentClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER, __VA_ARGS__)
 #define emberAfKeyEstablishmentClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfKeyEstablishmentClusterFlush()
 #define emberAfKeyEstablishmentClusterDebugExec(x)                                                                                 \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER))                                                             \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfKeyEstablishmentClusterPrintBuffer(buffer, len, withSpace)                                                          \
     emberAfPrintBuffer(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfKeyEstablishmentClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER, (buffer))
 #else
 #define emberAfKeyEstablishmentClusterPrint(...)
 #define emberAfKeyEstablishmentClusterPrintln(...)
 #define emberAfKeyEstablishmentClusterFlush()
 #define emberAfKeyEstablishmentClusterDebugExec(x)
 #define emberAfKeyEstablishmentClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfKeyEstablishmentClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER)

 // Printing macros for cluster: Information
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_INFORMATION_CLUSTER)
 #define emberAfInformationClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_INFORMATION_CLUSTER, __VA_ARGS__)
 #define emberAfInformationClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_INFORMATION_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfInformationClusterFlush()
 #define emberAfInformationClusterDebugExec(x)                                                                                      \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_INFORMATION_CLUSTER))                                                                   \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfInformationClusterPrintBuffer(buffer, len, withSpace)                                                               \
     emberAfPrintBuffer(EMBER_AF_PRINT_INFORMATION_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfInformationClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_INFORMATION_CLUSTER, (buffer))
 #else
 #define emberAfInformationClusterPrint(...)
 #define emberAfInformationClusterPrintln(...)
 #define emberAfInformationClusterFlush()
 #define emberAfInformationClusterDebugExec(x)
 #define emberAfInformationClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfInformationClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_INFORMATION_CLUSTER)

 // Printing macros for cluster: Data Sharing
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DATA_SHARING_CLUSTER)
 #define emberAfDataSharingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DATA_SHARING_CLUSTER, __VA_ARGS__)
 #define emberAfDataSharingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DATA_SHARING_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfDataSharingClusterFlush()
 #define emberAfDataSharingClusterDebugExec(x)                                                                                      \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_DATA_SHARING_CLUSTER))                                                                  \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfDataSharingClusterPrintBuffer(buffer, len, withSpace)                                                               \
     emberAfPrintBuffer(EMBER_AF_PRINT_DATA_SHARING_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfDataSharingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DATA_SHARING_CLUSTER, (buffer))
 #else
 #define emberAfDataSharingClusterPrint(...)
 #define emberAfDataSharingClusterPrintln(...)
 #define emberAfDataSharingClusterFlush()
 #define emberAfDataSharingClusterDebugExec(x)
 #define emberAfDataSharingClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfDataSharingClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DATA_SHARING_CLUSTER)

 // Printing macros for cluster: Gaming
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GAMING_CLUSTER)
 #define emberAfGamingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_GAMING_CLUSTER, __VA_ARGS__)
 #define emberAfGamingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_GAMING_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfGamingClusterFlush()
 #define emberAfGamingClusterDebugExec(x)                                                                                           \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_GAMING_CLUSTER))                                                                        \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfGamingClusterPrintBuffer(buffer, len, withSpace)                                                                    \
     emberAfPrintBuffer(EMBER_AF_PRINT_GAMING_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfGamingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_GAMING_CLUSTER, (buffer))
 #else
 #define emberAfGamingClusterPrint(...)
 #define emberAfGamingClusterPrintln(...)
 #define emberAfGamingClusterFlush()
 #define emberAfGamingClusterDebugExec(x)
 #define emberAfGamingClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfGamingClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GAMING_CLUSTER)

 // Printing macros for cluster: Data Rate Control
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER)
 #define emberAfDataRateControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER, __VA_ARGS__)
 #define emberAfDataRateControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfDataRateControlClusterFlush()
 #define emberAfDataRateControlClusterDebugExec(x)                                                                                  \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER))                                                             \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfDataRateControlClusterPrintBuffer(buffer, len, withSpace)                                                           \
     emberAfPrintBuffer(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfDataRateControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER, (buffer))
 #else
 #define emberAfDataRateControlClusterPrint(...)
 #define emberAfDataRateControlClusterPrintln(...)
 #define emberAfDataRateControlClusterFlush()
 #define emberAfDataRateControlClusterDebugExec(x)
 #define emberAfDataRateControlClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfDataRateControlClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER)

 // Printing macros for cluster: Voice over ZigBee
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER)
 #define emberAfVoiceOverZigbeeClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER, __VA_ARGS__)
 #define emberAfVoiceOverZigbeeClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfVoiceOverZigbeeClusterFlush()
 #define emberAfVoiceOverZigbeeClusterDebugExec(x)                                                                                  \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER))                                                             \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfVoiceOverZigbeeClusterPrintBuffer(buffer, len, withSpace)                                                           \
     emberAfPrintBuffer(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfVoiceOverZigbeeClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER, (buffer))
 #else
 #define emberAfVoiceOverZigbeeClusterPrint(...)
 #define emberAfVoiceOverZigbeeClusterPrintln(...)
 #define emberAfVoiceOverZigbeeClusterFlush()
 #define emberAfVoiceOverZigbeeClusterDebugExec(x)
 #define emberAfVoiceOverZigbeeClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfVoiceOverZigbeeClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER)

 // Printing macros for cluster: Chatting
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHATTING_CLUSTER)
 #define emberAfChattingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_CHATTING_CLUSTER, __VA_ARGS__)
 #define emberAfChattingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_CHATTING_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfChattingClusterFlush()
 #define emberAfChattingClusterDebugExec(x)                                                                                         \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_CHATTING_CLUSTER))                                                                      \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfChattingClusterPrintBuffer(buffer, len, withSpace)                                                                  \
     emberAfPrintBuffer(EMBER_AF_PRINT_CHATTING_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfChattingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CHATTING_CLUSTER, (buffer))
 #else
 #define emberAfChattingClusterPrint(...)
 #define emberAfChattingClusterPrintln(...)
 #define emberAfChattingClusterFlush()
 #define emberAfChattingClusterDebugExec(x)
 #define emberAfChattingClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfChattingClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHATTING_CLUSTER)

 // Printing macros for cluster: Payment
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PAYMENT_CLUSTER)
 #define emberAfPaymentClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_PAYMENT_CLUSTER, __VA_ARGS__)
 #define emberAfPaymentClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PAYMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfPaymentClusterFlush()
 #define emberAfPaymentClusterDebugExec(x)                                                                                          \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_PAYMENT_CLUSTER))                                                                       \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfPaymentClusterPrintBuffer(buffer, len, withSpace)                                                                   \
     emberAfPrintBuffer(EMBER_AF_PRINT_PAYMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfPaymentClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_PAYMENT_CLUSTER, (buffer))
 #else
 #define emberAfPaymentClusterPrint(...)
 #define emberAfPaymentClusterPrintln(...)
 #define emberAfPaymentClusterFlush()
 #define emberAfPaymentClusterDebugExec(x)
 #define emberAfPaymentClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfPaymentClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PAYMENT_CLUSTER)

 // Printing macros for cluster: Billing
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BILLING_CLUSTER)
 #define emberAfBillingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BILLING_CLUSTER, __VA_ARGS__)
 #define emberAfBillingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BILLING_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfBillingClusterFlush()
 #define emberAfBillingClusterDebugExec(x)                                                                                          \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_BILLING_CLUSTER))                                                                       \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfBillingClusterPrintBuffer(buffer, len, withSpace)                                                                   \
     emberAfPrintBuffer(EMBER_AF_PRINT_BILLING_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfBillingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BILLING_CLUSTER, (buffer))
 #else
 #define emberAfBillingClusterPrint(...)
 #define emberAfBillingClusterPrintln(...)
 #define emberAfBillingClusterFlush()
 #define emberAfBillingClusterDebugExec(x)
 #define emberAfBillingClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfBillingClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BILLING_CLUSTER)

 // Printing macros for cluster: Appliance Identification
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER)
 #define emberAfApplianceIdentificationClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER, __VA_ARGS__)
 #define emberAfApplianceIdentificationClusterPrintln(...)                                                                          \
     emberAfPrintln(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfApplianceIdentificationClusterFlush()
 #define emberAfApplianceIdentificationClusterDebugExec(x)                                                                          \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER))                                                      \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfApplianceIdentificationClusterPrintBuffer(buffer, len, withSpace)                                                   \
     emberAfPrintBuffer(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfApplianceIdentificationClusterPrintString(buffer)                                                                   \
     emberAfPrintString(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER, (buffer))
 #else
 #define emberAfApplianceIdentificationClusterPrint(...)
 #define emberAfApplianceIdentificationClusterPrintln(...)
 #define emberAfApplianceIdentificationClusterFlush()
 #define emberAfApplianceIdentificationClusterDebugExec(x)
 #define emberAfApplianceIdentificationClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfApplianceIdentificationClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER)

 // Printing macros for cluster: Meter Identification
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER)
 #define emberAfMeterIdentificationClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER, __VA_ARGS__)
 #define emberAfMeterIdentificationClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfMeterIdentificationClusterFlush()
 #define emberAfMeterIdentificationClusterDebugExec(x)                                                                              \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER))                                                          \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfMeterIdentificationClusterPrintBuffer(buffer, len, withSpace)                                                       \
     emberAfPrintBuffer(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfMeterIdentificationClusterPrintString(buffer)                                                                       \
     emberAfPrintString(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER, (buffer))
 #else
 #define emberAfMeterIdentificationClusterPrint(...)
 #define emberAfMeterIdentificationClusterPrintln(...)
 #define emberAfMeterIdentificationClusterFlush()
 #define emberAfMeterIdentificationClusterDebugExec(x)
 #define emberAfMeterIdentificationClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfMeterIdentificationClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER)

 // Printing macros for cluster: Appliance Events and Alert
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER)
 #define emberAfApplianceEventsAndAlertClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER, __VA_ARGS__)
 #define emberAfApplianceEventsAndAlertClusterPrintln(...)                                                                          \
     emberAfPrintln(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfApplianceEventsAndAlertClusterFlush()
 #define emberAfApplianceEventsAndAlertClusterDebugExec(x)                                                                          \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER))                                                    \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfApplianceEventsAndAlertClusterPrintBuffer(buffer, len, withSpace)                                                   \
     emberAfPrintBuffer(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfApplianceEventsAndAlertClusterPrintString(buffer)                                                                   \
     emberAfPrintString(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER, (buffer))
 #else
 #define emberAfApplianceEventsAndAlertClusterPrint(...)
 #define emberAfApplianceEventsAndAlertClusterPrintln(...)
 #define emberAfApplianceEventsAndAlertClusterFlush()
 #define emberAfApplianceEventsAndAlertClusterDebugExec(x)
 #define emberAfApplianceEventsAndAlertClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfApplianceEventsAndAlertClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER)

 // Printing macros for cluster: Appliance Statistics
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER)
 #define emberAfApplianceStatisticsClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER, __VA_ARGS__)
 #define emberAfApplianceStatisticsClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfApplianceStatisticsClusterFlush()
 #define emberAfApplianceStatisticsClusterDebugExec(x)                                                                              \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER))                                                          \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfApplianceStatisticsClusterPrintBuffer(buffer, len, withSpace)                                                       \
     emberAfPrintBuffer(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfApplianceStatisticsClusterPrintString(buffer)                                                                       \
     emberAfPrintString(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER, (buffer))
 #else
 #define emberAfApplianceStatisticsClusterPrint(...)
 #define emberAfApplianceStatisticsClusterPrintln(...)
 #define emberAfApplianceStatisticsClusterFlush()
 #define emberAfApplianceStatisticsClusterDebugExec(x)
 #define emberAfApplianceStatisticsClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfApplianceStatisticsClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER)

 // Printing macros for cluster: Electrical Measurement
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER)
 #define emberAfElectricalMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER, __VA_ARGS__)
 #define emberAfElectricalMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfElectricalMeasurementClusterFlush()
 #define emberAfElectricalMeasurementClusterDebugExec(x)                                                                            \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER))                                                        \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfElectricalMeasurementClusterPrintBuffer(buffer, len, withSpace)                                                     \
     emberAfPrintBuffer(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfElectricalMeasurementClusterPrintString(buffer)                                                                     \
     emberAfPrintString(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER, (buffer))
 #else
 #define emberAfElectricalMeasurementClusterPrint(...)
 #define emberAfElectricalMeasurementClusterPrintln(...)
 #define emberAfElectricalMeasurementClusterFlush()
 #define emberAfElectricalMeasurementClusterDebugExec(x)
 #define emberAfElectricalMeasurementClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfElectricalMeasurementClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER)

 // Printing macros for cluster: Diagnostics
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER)
 #define emberAfDiagnosticsClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER, __VA_ARGS__)
 #define emberAfDiagnosticsClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfDiagnosticsClusterFlush()
 #define emberAfDiagnosticsClusterDebugExec(x)                                                                                      \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER))                                                                   \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfDiagnosticsClusterPrintBuffer(buffer, len, withSpace)                                                               \
     emberAfPrintBuffer(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfDiagnosticsClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER, (buffer))
 #else
 #define emberAfDiagnosticsClusterPrint(...)
 #define emberAfDiagnosticsClusterPrintln(...)
 #define emberAfDiagnosticsClusterFlush()
 #define emberAfDiagnosticsClusterDebugExec(x)
 #define emberAfDiagnosticsClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfDiagnosticsClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER)

 // Printing macros for cluster: ZLL Commissioning
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER)
 #define emberAfZllCommissioningClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER, __VA_ARGS__)
 #define emberAfZllCommissioningClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfZllCommissioningClusterFlush()
 #define emberAfZllCommissioningClusterDebugExec(x)                                                                                 \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER))                                                             \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfZllCommissioningClusterPrintBuffer(buffer, len, withSpace)                                                          \
     emberAfPrintBuffer(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfZllCommissioningClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER, (buffer))
 #else
 #define emberAfZllCommissioningClusterPrint(...)
 #define emberAfZllCommissioningClusterPrintln(...)
 #define emberAfZllCommissioningClusterFlush()
 #define emberAfZllCommissioningClusterDebugExec(x)
 #define emberAfZllCommissioningClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfZllCommissioningClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER)

 // Printing macros for cluster: Sample Mfg Specific Cluster
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER)
 #define emberAfSampleMfgSpecificClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER, __VA_ARGS__)
 #define emberAfSampleMfgSpecificClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfSampleMfgSpecificClusterFlush()
 #define emberAfSampleMfgSpecificClusterDebugExec(x)                                                                                \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER))                                                           \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfSampleMfgSpecificClusterPrintBuffer(buffer, len, withSpace)                                                         \
     emberAfPrintBuffer(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfSampleMfgSpecificClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER, (buffer))
 #else
 #define emberAfSampleMfgSpecificClusterPrint(...)
 #define emberAfSampleMfgSpecificClusterPrintln(...)
 #define emberAfSampleMfgSpecificClusterFlush()
 #define emberAfSampleMfgSpecificClusterDebugExec(x)
 #define emberAfSampleMfgSpecificClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfSampleMfgSpecificClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER)

 // Printing macros for cluster: Sample Mfg Specific Cluster 2
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2)
 #define emberAfSampleMfgSpecificCluster2Print(...) emberAfPrint(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2, __VA_ARGS__)
 #define emberAfSampleMfgSpecificCluster2Println(...) emberAfPrintln(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfSampleMfgSpecificCluster2Flush()
 #define emberAfSampleMfgSpecificCluster2DebugExec(x)                                                                               \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2))                                                         \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfSampleMfgSpecificCluster2PrintBuffer(buffer, len, withSpace)                                                        \
     emberAfPrintBuffer(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2, (buffer), (len), (withSpace))
 #define emberAfSampleMfgSpecificCluster2PrintString(buffer)                                                                        \
     emberAfPrintString(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2, (buffer))
 #else
 #define emberAfSampleMfgSpecificCluster2Print(...)
 #define emberAfSampleMfgSpecificCluster2Println(...)
 #define emberAfSampleMfgSpecificCluster2Flush()
 #define emberAfSampleMfgSpecificCluster2DebugExec(x)
 #define emberAfSampleMfgSpecificCluster2PrintBuffer(buffer, len, withSpace)
 #define emberAfSampleMfgSpecificCluster2PrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2)

 // Printing macros for cluster: Configuration Cluster
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER)
 #define emberAfOtaConfigurationClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER, __VA_ARGS__)
 #define emberAfOtaConfigurationClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfOtaConfigurationClusterFlush()
 #define emberAfOtaConfigurationClusterDebugExec(x)                                                                                 \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER))                                                             \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfOtaConfigurationClusterPrintBuffer(buffer, len, withSpace)                                                          \
     emberAfPrintBuffer(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfOtaConfigurationClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER, (buffer))
 #else
 #define emberAfOtaConfigurationClusterPrint(...)
 #define emberAfOtaConfigurationClusterPrintln(...)
 #define emberAfOtaConfigurationClusterFlush()
 #define emberAfOtaConfigurationClusterDebugExec(x)
 #define emberAfOtaConfigurationClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfOtaConfigurationClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER)

 // Printing macros for cluster: MFGLIB Cluster
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MFGLIB_CLUSTER)
 #define emberAfMfglibClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_MFGLIB_CLUSTER, __VA_ARGS__)
 #define emberAfMfglibClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_MFGLIB_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfMfglibClusterFlush()
 #define emberAfMfglibClusterDebugExec(x)                                                                                           \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_MFGLIB_CLUSTER))                                                                        \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfMfglibClusterPrintBuffer(buffer, len, withSpace)                                                                    \
     emberAfPrintBuffer(EMBER_AF_PRINT_MFGLIB_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfMfglibClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_MFGLIB_CLUSTER, (buffer))
 #else
 #define emberAfMfglibClusterPrint(...)
 #define emberAfMfglibClusterPrintln(...)
 #define emberAfMfglibClusterFlush()
 #define emberAfMfglibClusterDebugExec(x)
 #define emberAfMfglibClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfMfglibClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MFGLIB_CLUSTER)

 // Printing macros for cluster: SL Works With All Hubs
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SL_WWAH_CLUSTER)
 #define emberAfSlWwahClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SL_WWAH_CLUSTER, __VA_ARGS__)
 #define emberAfSlWwahClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SL_WWAH_CLUSTER, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfSlWwahClusterFlush()
 #define emberAfSlWwahClusterDebugExec(x)                                                                                           \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_SL_WWAH_CLUSTER))                                                                       \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfSlWwahClusterPrintBuffer(buffer, len, withSpace)                                                                    \
     emberAfPrintBuffer(EMBER_AF_PRINT_SL_WWAH_CLUSTER, (buffer), (len), (withSpace))
 #define emberAfSlWwahClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SL_WWAH_CLUSTER, (buffer))
 #else
 #define emberAfSlWwahClusterPrint(...)
 #define emberAfSlWwahClusterPrintln(...)
 #define emberAfSlWwahClusterFlush()
 #define emberAfSlWwahClusterDebugExec(x)
 #define emberAfSlWwahClusterPrintBuffer(buffer, len, withSpace)
 #define emberAfSlWwahClusterPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SL_WWAH_CLUSTER)

 // Printing macros for Core
 // Prints messages for global flow of the receive/send
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CORE)
 #define emberAfCorePrint(...) emberAfPrint(EMBER_AF_PRINT_CORE, __VA_ARGS__)
 #define emberAfCorePrintln(...) emberAfPrintln(EMBER_AF_PRINT_CORE, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfCoreFlush()
 #define emberAfCoreDebugExec(x)                                                                                                    \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_CORE))                                                                                  \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfCorePrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CORE, (buffer), (len), (withSpace))
 #define emberAfCorePrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CORE, (buffer))
 #else
 #define emberAfCorePrint(...)
 #define emberAfCorePrintln(...)
 #define emberAfCoreFlush()
 #define emberAfCoreDebugExec(x)
 #define emberAfCorePrintBuffer(buffer, len, withSpace)
 #define emberAfCorePrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CORE)

 // Printing macros for Debug
 // Prints messages for random debugging
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEBUG)
 #define emberAfDebugPrint(...) emberAfPrint(EMBER_AF_PRINT_DEBUG, __VA_ARGS__)
 #define emberAfDebugPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DEBUG, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfDebugFlush()
 #define emberAfDebugDebugExec(x)                                                                                                   \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_DEBUG))                                                                                 \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfDebugPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_DEBUG, (buffer), (len), (withSpace))
 #define emberAfDebugPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DEBUG, (buffer))
 #else
 #define emberAfDebugPrint(...)
 #define emberAfDebugPrintln(...)
 #define emberAfDebugFlush()
 #define emberAfDebugDebugExec(x)
 #define emberAfDebugPrintBuffer(buffer, len, withSpace)
 #define emberAfDebugPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEBUG)

 // Printing macros for Application
 // Prints messages for application part
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APP)
 #define emberAfAppPrint(...) emberAfPrint(EMBER_AF_PRINT_APP, __VA_ARGS__)
 #define emberAfAppPrintln(...) emberAfPrintln(EMBER_AF_PRINT_APP, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfAppFlush()
 #define emberAfAppDebugExec(x)                                                                                                     \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_APP))                                                                                   \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfAppPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_APP, (buffer), (len), (withSpace))
 #define emberAfAppPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_APP, (buffer))
 #else
 #define emberAfAppPrint(...)
 #define emberAfAppPrintln(...)
 #define emberAfAppFlush()
 #define emberAfAppDebugExec(x)
 #define emberAfAppPrintBuffer(buffer, len, withSpace)
 #define emberAfAppPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APP)

 // Printing macros for Attributes
 // Prints messages related to attributes
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ATTRIBUTES)
 #define emberAfAttributesPrint(...) emberAfPrint(EMBER_AF_PRINT_ATTRIBUTES, __VA_ARGS__)
 #define emberAfAttributesPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ATTRIBUTES, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfAttributesFlush()
 #define emberAfAttributesDebugExec(x)                                                                                              \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_ATTRIBUTES))                                                                            \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfAttributesPrintBuffer(buffer, len, withSpace)                                                                       \
     emberAfPrintBuffer(EMBER_AF_PRINT_ATTRIBUTES, (buffer), (len), (withSpace))
 #define emberAfAttributesPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ATTRIBUTES, (buffer))
 #else
 #define emberAfAttributesPrint(...)
 #define emberAfAttributesPrintln(...)
 #define emberAfAttributesFlush()
 #define emberAfAttributesDebugExec(x)
 #define emberAfAttributesPrintBuffer(buffer, len, withSpace)
 #define emberAfAttributesPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ATTRIBUTES)

 // Printing macros for Reporting
 // Prints messages related to reporting
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_REPORTING)
 #define emberAfReportingPrint(...) emberAfPrint(EMBER_AF_PRINT_REPORTING, __VA_ARGS__)
 #define emberAfReportingPrintln(...) emberAfPrintln(EMBER_AF_PRINT_REPORTING, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfReportingFlush()
 #define emberAfReportingDebugExec(x)                                                                                               \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_REPORTING))                                                                             \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfReportingPrintBuffer(buffer, len, withSpace)                                                                        \
     emberAfPrintBuffer(EMBER_AF_PRINT_REPORTING, (buffer), (len), (withSpace))
 #define emberAfReportingPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_REPORTING, (buffer))
 #else
 #define emberAfReportingPrint(...)
 #define emberAfReportingPrintln(...)
 #define emberAfReportingFlush()
 #define emberAfReportingDebugExec(x)
 #define emberAfReportingPrintBuffer(buffer, len, withSpace)
 #define emberAfReportingPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_REPORTING)

 // Printing macros for Service discovery
 // Prints messages related to service discovery
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SERVICE_DISCOVERY)
 #define emberAfServiceDiscoveryPrint(...) emberAfPrint(EMBER_AF_PRINT_SERVICE_DISCOVERY, __VA_ARGS__)
 #define emberAfServiceDiscoveryPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SERVICE_DISCOVERY, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfServiceDiscoveryFlush()
 #define emberAfServiceDiscoveryDebugExec(x)                                                                                        \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_SERVICE_DISCOVERY))                                                                     \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfServiceDiscoveryPrintBuffer(buffer, len, withSpace)                                                                 \
     emberAfPrintBuffer(EMBER_AF_PRINT_SERVICE_DISCOVERY, (buffer), (len), (withSpace))
 #define emberAfServiceDiscoveryPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SERVICE_DISCOVERY, (buffer))
 #else
 #define emberAfServiceDiscoveryPrint(...)
 #define emberAfServiceDiscoveryPrintln(...)
 #define emberAfServiceDiscoveryFlush()
 #define emberAfServiceDiscoveryDebugExec(x)
 #define emberAfServiceDiscoveryPrintBuffer(buffer, len, withSpace)
 #define emberAfServiceDiscoveryPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SERVICE_DISCOVERY)

 // Printing macros for Registration
 // Prints messages related to registration
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_REGISTRATION)
 #define emberAfRegistrationPrint(...) emberAfPrint(EMBER_AF_PRINT_REGISTRATION, __VA_ARGS__)
 #define emberAfRegistrationPrintln(...) emberAfPrintln(EMBER_AF_PRINT_REGISTRATION, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfRegistrationFlush()
 #define emberAfRegistrationDebugExec(x)                                                                                            \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_REGISTRATION))                                                                          \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfRegistrationPrintBuffer(buffer, len, withSpace)                                                                     \
     emberAfPrintBuffer(EMBER_AF_PRINT_REGISTRATION, (buffer), (len), (withSpace))
 #define emberAfRegistrationPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_REGISTRATION, (buffer))
 #else
 #define emberAfRegistrationPrint(...)
 #define emberAfRegistrationPrintln(...)
 #define emberAfRegistrationFlush()
 #define emberAfRegistrationDebugExec(x)
 #define emberAfRegistrationPrintBuffer(buffer, len, withSpace)
 #define emberAfRegistrationPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_REGISTRATION)

 // Printing macros for ZDO (ZigBee Device Object)
 // Prints messages related to ZDO functionality
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ZDO)
 #define emberAfZdoPrint(...) emberAfPrint(EMBER_AF_PRINT_ZDO, __VA_ARGS__)
 #define emberAfZdoPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ZDO, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfZdoFlush()
 #define emberAfZdoDebugExec(x)                                                                                                     \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_ZDO))                                                                                   \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfZdoPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ZDO, (buffer), (len), (withSpace))
 #define emberAfZdoPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ZDO, (buffer))
 #else
 #define emberAfZdoPrint(...)
 #define emberAfZdoPrintln(...)
 #define emberAfZdoFlush()
 #define emberAfZdoDebugExec(x)
 #define emberAfZdoPrintBuffer(buffer, len, withSpace)
 #define emberAfZdoPrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ZDO)

 // Printing macros for Custom messages (1)
 // Messages that can be used by the end developer
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CUSTOM1)
 #define emberAfCustom1Print(...) emberAfPrint(EMBER_AF_PRINT_CUSTOM1, __VA_ARGS__)
 #define emberAfCustom1Println(...) emberAfPrintln(EMBER_AF_PRINT_CUSTOM1, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfCustom1Flush()
 #define emberAfCustom1DebugExec(x)                                                                                                 \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_CUSTOM1))                                                                               \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfCustom1PrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CUSTOM1, (buffer), (len), (withSpace))
 #define emberAfCustom1PrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CUSTOM1, (buffer))
 #else
 #define emberAfCustom1Print(...)
 #define emberAfCustom1Println(...)
 #define emberAfCustom1Flush()
 #define emberAfCustom1DebugExec(x)
 #define emberAfCustom1PrintBuffer(buffer, len, withSpace)
 #define emberAfCustom1PrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CUSTOM1)

 // Printing macros for Custom messages (2)
 // Messages that can be used by the end developer
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CUSTOM2)
 #define emberAfCustom2Print(...) emberAfPrint(EMBER_AF_PRINT_CUSTOM2, __VA_ARGS__)
 #define emberAfCustom2Println(...) emberAfPrintln(EMBER_AF_PRINT_CUSTOM2, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfCustom2Flush()
 #define emberAfCustom2DebugExec(x)                                                                                                 \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_CUSTOM2))                                                                               \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfCustom2PrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CUSTOM2, (buffer), (len), (withSpace))
 #define emberAfCustom2PrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CUSTOM2, (buffer))
 #else
 #define emberAfCustom2Print(...)
 #define emberAfCustom2Println(...)
 #define emberAfCustom2Flush()
 #define emberAfCustom2DebugExec(x)
 #define emberAfCustom2PrintBuffer(buffer, len, withSpace)
 #define emberAfCustom2PrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CUSTOM2)

 // Printing macros for Custom messages (3)
 // Messages that can be used by the end developer
 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CUSTOM3)
 #define emberAfCustom3Print(...) emberAfPrint(EMBER_AF_PRINT_CUSTOM3, __VA_ARGS__)
 #define emberAfCustom3Println(...) emberAfPrintln(EMBER_AF_PRINT_CUSTOM3, __VA_ARGS__)
 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 #define emberAfCustom3Flush()
 #define emberAfCustom3DebugExec(x)                                                                                                 \
     if (emberAfPrintEnabled(EMBER_AF_PRINT_CUSTOM3))                                                                               \
     {                                                                                                                              \
         x;                                                                                                                         \
     }
 #define emberAfCustom3PrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CUSTOM3, (buffer), (len), (withSpace))
 #define emberAfCustom3PrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CUSTOM3, (buffer))
 #else
 #define emberAfCustom3Print(...)
 #define emberAfCustom3Println(...)
 #define emberAfCustom3Flush()
 #define emberAfCustom3DebugExec(x)
 #define emberAfCustom3PrintBuffer(buffer, len, withSpace)
 #define emberAfCustom3PrintString(buffer)
 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CUSTOM3)