cli.c.bak

// This file is generated by Simplicity Studio.  Please do not edit manually.
//
//



#include "app/framework/include/af.h"
#include "app/framework/cli/custom-cli.h"


void changeKeyCommand(void);
void echoCommand(void);
void emAfCliBsendCommand(void);
void emAfCliInfoCommand(void);
void emAfCliRawCommand(void);
void emAfCliReadCommand(void);
void emAfCliSendCommand(void);
void emAfCliSendUsingMulticastBindingCommand(void);
void emAfCliTimesyncCommand(void);
void emAfCliVersionCommand(void);
void emAfCliWriteCommand(void);
void emAfOtaImageDelete(void);
#if defined(EMBER_TEST)
void emAfOtaLoadFileCommand(void);
#endif
void emAfOtaPrintAllImages(void);
void emAfOtaReloadStorageDevice(void);
void emAfOtaServerPolicyPrint(void);
void emAfOtaStorageDataPrint(void);
void emAfOtaStorageInfoPrint(void);
void emAfPluginIasZoneClientClearAllServersCommand(void);
void emAfPluginIasZoneClientPrintServersCommand(void);
void emAfPluginNetworkCreatorSecurityClearJoiningLinkKeyCommand(void);
void emAfPluginNetworkCreatorSecurityOpenNetworkWithKeyCommand(void);
void emAfPluginNetworkCreatorSecurityOpenOrCloseNetworkCommand(void);
void emAfPluginNetworkCreatorSecuritySetJoiningLinkKeyCommand(void);
void emAfPluginReportingCliAdd(void);
void emAfPluginReportingCliClear(void);
void emAfPluginReportingCliClearLastReportTime(void);
void emAfPluginReportingCliPrint(void);
void emAfPluginReportingCliRemove(void);
void emAfPluginSimpleMeteringClientCliGetSampledData(void);
void emAfPluginSimpleMeteringClientCliLocalChangeSupply(void);
void emAfPluginSimpleMeteringClientCliSchSnapshot(void);
void emAfPluginSimpleMeteringClientCliStartSampling(void);
#if defined(EMBER_AF_PLUGIN_TRUST_CENTER_BACKUP_POSIX_FILE_BACKUP_SUPPORT)
void emAfTcExportCommand(void);
#endif
#if defined(EMBER_AF_PLUGIN_TRUST_CENTER_BACKUP_POSIX_FILE_BACKUP_SUPPORT)
void emAfTcImportCommand(void);
#endif
void emAfTestHarnessStartImageStampCalculation(void);
void emberAfPluginAddressTableAddCommand(void);
void emberAfPluginAddressTableLookupCommand(void);
void emberAfPluginAddressTablePrintCommand(void);
void emberAfPluginAddressTableRemoveCommand(void);
void emberAfPluginAddressTableSetCommand(void);
void emberAfPluginConcentratorAggregationCommand(void);
void emberAfPluginConcentratorPrintHostSourceRouteTable(void);
void emberAfPluginConcentratorPrintSourceRouteTable(void);
void emberAfPluginConcentratorSetRouterBehaviorCommand(void);
void emberAfPluginConcentratorStartDiscovery(void);
void emberAfPluginConcentratorStatus(void);
void emberAfPluginConcentratorStopDiscovery(void);
void emberAfPluginCounterPrintCounterTypeCommand(void);
void emberAfPluginCountersClear(void);
void emberAfPluginCountersPrintCommand(void);
void emberAfPluginCountersPrintThresholdsCommand(void);
void emberAfPluginCountersResetThresholds(void);
void emberAfPluginCountersSendRequestCommand(void);
void emberAfPluginCountersSetThresholdCommand(void);
void emberAfPluginCountersSimplePrintCommand(void);
void emberAfPluginEzModeCommissioningClientCommand(void);
void emberAfPluginEzModeCommissioningServerCommand(void);
void emberAfPluginGatewaySupportTimeSyncLocal(void);
void emberAfPluginGreenPowerClientAddGroupcastSink(void);
void emberAfPluginGreenPowerClientAddSink(void);
void emberAfPluginGreenPowerClientClearProxyTable(void);
void emberAfPluginGreenPowerClientDuplicateFilteringTest(void);
void emberAfPluginGreenPowerClientPrintProxyTable(void);
void emberAfPluginGreenPowerClientRemoveProxyTableEntry(void);
void emberAfPluginGreenPowerClientSetKey(void);
void emberAfPluginGreenPowerClientSetProxyEntry(void);
void emberAfPluginNetworkCreatorChannelMaskCommand(void);
void emberAfPluginNetworkCreatorFormCommand(void);
void emberAfPluginNetworkCreatorStartCommand(void);
void emberAfPluginNetworkCreatorStatusCommand(void);
void emberAfPluginNetworkCreatorStop(void);
void emberAfPluginTestHarnessAddChildCommand(void);
void emberAfPluginTestHarnessCertMangleCommand(void);
#if defined(EMBER_AF_PLUGIN_NETWORK_FIND)
void emberAfPluginTestHarnessChannelMaskAddOrRemoveCommand(void);
#endif
#if defined(EMBER_AF_PLUGIN_NETWORK_FIND)
void emberAfPluginTestHarnessChannelMaskResetClearAllCommand(void);
#endif
void emberAfPluginTestHarnessClusterEndpointIndexCommand(void);
void emberAfPluginTestHarnessConcentratorStartStopCommand(void);
void emberAfPluginTestHarnessEnableDisableEndpointCommand(void);
void emberAfPluginTestHarnessEndpointStatusCommand(void);
void emberAfPluginTestHarnessKeyEstablishmentKeyMangleCommand(void);
void emberAfPluginTestHarnessKeyEstablishmentSelectSuiteCommand(void);
void emberAfPluginTestHarnessKeyEstablishmentSetAvailableSuiteCommand (void);
void emberAfPluginTestHarnessKeyEstablishmentSetModeCommand(void);
void emberAfPluginTestHarnessKeyUpdateCommand(void);
void emberAfPluginTestHarnessLimitBeaconsOnOffCommand(void);
void emberAfPluginTestHarnessOtaImageMangleCommand(void);
void emberAfPluginTestHarnessPriceSendNewFieldsCommand(void);
void emberAfPluginTestHarnessRadioOnOffCommand(void);
void emberAfPluginTestHarnessSetApsSecurityForClusterCommand(void);
void emberAfPluginTestHarnessSetNodeDescriptorComplianceRevision(void);
void emberAfPluginTestHarnessSetRadioPower(void);
void emberAfPluginTestHarnessSetRegistrationCommand(void);
void emberAfPluginTestHarnessStatusCommand(void);
void emberAfPluginTestHarnessTcKeepaliveSendCommand(void);
void emberAfPluginTestHarnessTcKeepaliveStartStopCommand(void);
void emberAfPrintAllOff(void);
void emberAfPrintAllOn(void);
void emberAfPrintAttributeTable(void);
void emberAfPrintEntropySource(void);
void emberAfPrintStatus(void);
void enableDisableEndpoint(void);
void endpointPrint(void);
void findJoinableNetworkCommand(void);
void findMaskCommand(void);
void findModeCommand(void);
void findPrintCommand(void);
void findUnusedPanIdCommand(void);
#if !defined(EMBER_AF_HAS_SECURITY_PROFILE_NONE)
void getSetMfgToken(void);
#endif
void helpCommand(void);
void importClearCommand(void);
void importKeyCommand(void);
void interpanCommand(void);
void interpanLongCommand(void);
void keysClearCommand(void);
void keysDeleteCommand(void);
void keysPrintCommand(void);
void mode(void);
void networkChangeChannelCommand(void);
void networkExtendedPanIdCommand(void);
void networkFormCommand(void);
void networkIdCommand(void);
void networkInitCommand(void);
void networkJoinCommand(void);
void networkLeaveCommand(void);
void networkMultiPhyStartCommand(void);
void networkMultiPhyStopCommand(void);
void networkPermitJoinCommand(void);
void networkRejoinCommand(void);
void networkRejoinDiffDeviceTypeCommand(void);
void networkSetCommand(void);
void optionApsRetryCommand(void);
void optionApsSecurityCommand(void);
void optionBindingTableClearCommand(void);
void optionBindingTablePrintCommand(void);
void optionBindingTableSetCommand(void);
void optionDiscoverCommand(void);
void optionEndDeviceBindCommand(void);
#if !defined(EMBER_AF_HAS_SECURITY_PROFILE_NONE)
void optionInstallCodeCommand(void);
#endif
void optionLinkCommand(void);
void optionPrintRxCommand(void);
void optionRegisterCommand(void);
void optionSecurityAllowTrustCenterRejoinUsingWellKnownKey(void);
void optionSecurityAllowTrustCenterRejoinUsingWellKnownKeyTimeout(void);
void optionSecuritySetKeyRequestPolicy(void);
void otaImageNotifyCommand(void);
void otaSendUpgradeCommand(void);
#if defined(EMBER_TEST)
void otaServerSetClientDelayUnits(void);
#endif
void print(void);
void printAllLibraryStatus(void);
void printChildTable(void);
void printEvents(void);
void printExportDataCommand(void);
void printImportDataCommand(void);
void printInfo(void);
void printNeighborTable(void);
void printOffCommand(void);
void printOnCommand(void);
void printRouteTable(void);
void printTimeCommand(void);
void resetCommand(void);
void respond(void);
void restoreFromBackupCommand(void);
void setDestinationCommand(void);
void setExtendedPanIdCommand(void);
void setOptionsCommand(void);
void setPolicy(void);
void startTestCommand(void);
void timeout(void);
static void zclBarrierControlGoToPercentCommand(void) {
  zclSimpleClientCommand( ZCL_BARRIER_CONTROL_CLUSTER_ID,
                          ZCL_BARRIER_CONTROL_GO_TO_PERCENT_COMMAND_ID);
}

static void zclBarrierControlStopCommand(void) {
  zclSimpleClientCommand( ZCL_BARRIER_CONTROL_CLUSTER_ID,
                          ZCL_BARRIER_CONTROL_STOP_COMMAND_ID);
}

static void zclBasicGlsCommand(void) {
  zclSimpleClientCommand( ZCL_BASIC_CLUSTER_ID,
                          ZCL_GET_LOCALES_SUPPORTED_COMMAND_ID);
}

static void zclBasicGlsrCommand(void) {
  zclSimpleServerCommand( ZCL_BASIC_CLUSTER_ID,
                          ZCL_GET_LOCALES_SUPPORTED_RESPONSE_COMMAND_ID);
}

static void zclBasicRtfdCommand(void) {
  zclSimpleClientCommand( ZCL_BASIC_CLUSTER_ID,
                          ZCL_RESET_TO_FACTORY_DEFAULTS_COMMAND_ID);
}

static void zclColorControlEmovehueCommand(void) {
  zclSimpleClientCommand( ZCL_COLOR_CONTROL_CLUSTER_ID,
                          ZCL_ENHANCED_MOVE_HUE_COMMAND_ID);
}

static void zclColorControlEmovetohueCommand(void) {
  zclSimpleClientCommand( ZCL_COLOR_CONTROL_CLUSTER_ID,
                          ZCL_ENHANCED_MOVE_TO_HUE_COMMAND_ID);
}

static void zclColorControlEmovetohueandsatCommand(void) {
  zclSimpleClientCommand( ZCL_COLOR_CONTROL_CLUSTER_ID,
                          ZCL_ENHANCED_MOVE_TO_HUE_AND_SATURATION_COMMAND_ID);
}

static void zclColorControlEstephueCommand(void) {
  zclSimpleClientCommand( ZCL_COLOR_CONTROL_CLUSTER_ID,
                          ZCL_ENHANCED_STEP_HUE_COMMAND_ID);
}

static void zclColorControlLoopCommand(void) {
  zclSimpleClientCommand( ZCL_COLOR_CONTROL_CLUSTER_ID,
                          ZCL_COLOR_LOOP_SET_COMMAND_ID);
}

static void zclColorControlMovecolorCommand(void) {
  zclSimpleClientCommand( ZCL_COLOR_CONTROL_CLUSTER_ID,
                          ZCL_MOVE_COLOR_COMMAND_ID);
}

static void zclColorControlMovecolortempCommand(void) {
  zclSimpleClientCommand( ZCL_COLOR_CONTROL_CLUSTER_ID,
                          ZCL_MOVE_COLOR_TEMPERATURE_COMMAND_ID);
}

static void zclColorControlMovehueCommand(void) {
  zclSimpleClientCommand( ZCL_COLOR_CONTROL_CLUSTER_ID,
                          ZCL_MOVE_HUE_COMMAND_ID);
}

static void zclColorControlMovesatCommand(void) {
  zclSimpleClientCommand( ZCL_COLOR_CONTROL_CLUSTER_ID,
                          ZCL_MOVE_SATURATION_COMMAND_ID);
}

static void zclColorControlMovetocolorCommand(void) {
  zclSimpleClientCommand( ZCL_COLOR_CONTROL_CLUSTER_ID,
                          ZCL_MOVE_TO_COLOR_COMMAND_ID);
}

static void zclColorControlMovetocolortempCommand(void) {
  zclSimpleClientCommand( ZCL_COLOR_CONTROL_CLUSTER_ID,
                          ZCL_MOVE_TO_COLOR_TEMPERATURE_COMMAND_ID);
}

static void zclColorControlMovetohueCommand(void) {
  zclSimpleClientCommand( ZCL_COLOR_CONTROL_CLUSTER_ID,
                          ZCL_MOVE_TO_HUE_COMMAND_ID);
}

static void zclColorControlMovetohueandsatCommand(void) {
  zclSimpleClientCommand( ZCL_COLOR_CONTROL_CLUSTER_ID,
                          ZCL_MOVE_TO_HUE_AND_SATURATION_COMMAND_ID);
}

static void zclColorControlMovetosatCommand(void) {
  zclSimpleClientCommand( ZCL_COLOR_CONTROL_CLUSTER_ID,
                          ZCL_MOVE_TO_SATURATION_COMMAND_ID);
}

static void zclColorControlStepcolorCommand(void) {
  zclSimpleClientCommand( ZCL_COLOR_CONTROL_CLUSTER_ID,
                          ZCL_STEP_COLOR_COMMAND_ID);
}

static void zclColorControlStepcolortempCommand(void) {
  zclSimpleClientCommand( ZCL_COLOR_CONTROL_CLUSTER_ID,
                          ZCL_STEP_COLOR_TEMPERATURE_COMMAND_ID);
}

static void zclColorControlStephueCommand(void) {
  zclSimpleClientCommand( ZCL_COLOR_CONTROL_CLUSTER_ID,
                          ZCL_STEP_HUE_COMMAND_ID);
}

static void zclColorControlStepsatCommand(void) {
  zclSimpleClientCommand( ZCL_COLOR_CONTROL_CLUSTER_ID,
                          ZCL_STEP_SATURATION_COMMAND_ID);
}

static void zclColorControlStopmovestepCommand(void) {
  zclSimpleClientCommand( ZCL_COLOR_CONTROL_CLUSTER_ID,
                          ZCL_STOP_MOVE_STEP_COMMAND_ID);
}

void zclGlobalCommandDiscoveryCommand(void);
void zclGlobalDirectionCommand(void);
void zclGlobalDiscoverCommand(void);
void zclGlobalExpectReportFromMeCommand(void);
void zclGlobalReadCommand(void);
void zclGlobalReportCommand(void);
void zclGlobalReportReadCommand(void);
void zclGlobalSendMeAReportCommand(void);
void zclGlobalWriteCommand(void);
static void zclGroupsAddCommand(void) {
  zclSimpleClientCommand( ZCL_GROUPS_CLUSTER_ID,
                          ZCL_ADD_GROUP_COMMAND_ID);
}

static void zclGroupsAddIfIdCommand(void) {
  zclSimpleClientCommand( ZCL_GROUPS_CLUSTER_ID,
                          ZCL_ADD_GROUP_IF_IDENTIFYING_COMMAND_ID);
}

void zclGroupsGetCommand(void);
static void zclGroupsRemoveCommand(void) {
  zclSimpleClientCommand( ZCL_GROUPS_CLUSTER_ID,
                          ZCL_REMOVE_GROUP_COMMAND_ID);
}

static void zclGroupsRmallCommand(void) {
  zclSimpleClientCommand( ZCL_GROUPS_CLUSTER_ID,
                          ZCL_REMOVE_ALL_GROUPS_COMMAND_ID);
}

static void zclGroupsViewCommand(void) {
  zclSimpleClientCommand( ZCL_GROUPS_CLUSTER_ID,
                          ZCL_VIEW_GROUP_COMMAND_ID);
}

static void zclIdentifyEzModeCommand(void) {
  zclSimpleClientCommand( ZCL_IDENTIFY_CLUSTER_ID,
                          ZCL_E_Z_MODE_INVOKE_COMMAND_ID);
}

static void zclIdentifyIdCommand(void) {
  zclSimpleClientCommand( ZCL_IDENTIFY_CLUSTER_ID,
                          ZCL_IDENTIFY_COMMAND_ID);
}

static void zclIdentifyQueryCommand(void) {
  zclSimpleClientCommand( ZCL_IDENTIFY_CLUSTER_ID,
                          ZCL_IDENTIFY_QUERY_COMMAND_ID);
}

static void zclIdentifyTriggerCommand(void) {
  zclSimpleClientCommand( ZCL_IDENTIFY_CLUSTER_ID,
                          ZCL_TRIGGER_EFFECT_COMMAND_ID);
}

static void zclLevelControlMoveCommand(void) {
  zclSimpleClientCommand( ZCL_LEVEL_CONTROL_CLUSTER_ID,
                          ZCL_MOVE_COMMAND_ID);
}

static void zclLevelControlMvToLevelCommand(void) {
  zclSimpleClientCommand( ZCL_LEVEL_CONTROL_CLUSTER_ID,
                          ZCL_MOVE_TO_LEVEL_COMMAND_ID);
}

static void zclLevelControlOMoveCommand(void) {
  zclSimpleClientCommand( ZCL_LEVEL_CONTROL_CLUSTER_ID,
                          ZCL_MOVE_WITH_ON_OFF_COMMAND_ID);
}

static void zclLevelControlOMvToLevelCommand(void) {
  zclSimpleClientCommand( ZCL_LEVEL_CONTROL_CLUSTER_ID,
                          ZCL_MOVE_TO_LEVEL_WITH_ON_OFF_COMMAND_ID);
}

static void zclLevelControlOStepCommand(void) {
  zclSimpleClientCommand( ZCL_LEVEL_CONTROL_CLUSTER_ID,
                          ZCL_STEP_WITH_ON_OFF_COMMAND_ID);
}

static void zclLevelControlOStopCommand(void) {
  zclSimpleClientCommand( ZCL_LEVEL_CONTROL_CLUSTER_ID,
                          ZCL_STOP_WITH_ON_OFF_COMMAND_ID);
}

static void zclLevelControlStepCommand(void) {
  zclSimpleClientCommand( ZCL_LEVEL_CONTROL_CLUSTER_ID,
                          ZCL_STEP_COMMAND_ID);
}

static void zclLevelControlStopCommand(void) {
  zclSimpleClientCommand( ZCL_LEVEL_CONTROL_CLUSTER_ID,
                          ZCL_STOP_COMMAND_ID);
}

static void zclLockClearAllRfidsCommand(void) {
  zclSimpleClientCommand( ZCL_DOOR_LOCK_CLUSTER_ID,
                          ZCL_CLEAR_ALL_RFIDS_COMMAND_ID);
}

static void zclLockClearHolidayScheduleCommand(void) {
  zclSimpleClientCommand( ZCL_DOOR_LOCK_CLUSTER_ID,
                          ZCL_CLEAR_HOLIDAY_SCHEDULE_COMMAND_ID);
}

static void zclLockClearPinCommand(void) {
  zclSimpleClientCommand( ZCL_DOOR_LOCK_CLUSTER_ID,
                          ZCL_CLEAR_PIN_COMMAND_ID);
}

static void zclLockClearRfidCommand(void) {
  zclSimpleClientCommand( ZCL_DOOR_LOCK_CLUSTER_ID,
                          ZCL_CLEAR_RFID_COMMAND_ID);
}

static void zclLockClearWeekdayScheduleCommand(void) {
  zclSimpleClientCommand( ZCL_DOOR_LOCK_CLUSTER_ID,
                          ZCL_CLEAR_WEEKDAY_SCHEDULE_COMMAND_ID);
}

static void zclLockClearYeardayScheduleCommand(void) {
  zclSimpleClientCommand( ZCL_DOOR_LOCK_CLUSTER_ID,
                          ZCL_CLEAR_YEARDAY_SCHEDULE_COMMAND_ID);
}

static void zclLockGetHolidayScheduleCommand(void) {
  zclSimpleClientCommand( ZCL_DOOR_LOCK_CLUSTER_ID,
                          ZCL_GET_HOLIDAY_SCHEDULE_COMMAND_ID);
}

static void zclLockGetLogRecordCommand(void) {
  zclSimpleClientCommand( ZCL_DOOR_LOCK_CLUSTER_ID,
                          ZCL_GET_LOG_RECORD_COMMAND_ID);
}

static void zclLockGetPinCommand(void) {
  zclSimpleClientCommand( ZCL_DOOR_LOCK_CLUSTER_ID,
                          ZCL_GET_PIN_COMMAND_ID);
}

static void zclLockGetRfidCommand(void) {
  zclSimpleClientCommand( ZCL_DOOR_LOCK_CLUSTER_ID,
                          ZCL_GET_RFID_COMMAND_ID);
}

static void zclLockGetUserTypeCommand(void) {
  zclSimpleClientCommand( ZCL_DOOR_LOCK_CLUSTER_ID,
                          ZCL_GET_USER_TYPE_COMMAND_ID);
}

static void zclLockGetWeekdayScheduleCommand(void) {
  zclSimpleClientCommand( ZCL_DOOR_LOCK_CLUSTER_ID,
                          ZCL_GET_WEEKDAY_SCHEDULE_COMMAND_ID);
}

static void zclLockGetYeardayScheduleCommand(void) {
  zclSimpleClientCommand( ZCL_DOOR_LOCK_CLUSTER_ID,
                          ZCL_GET_YEARDAY_SCHEDULE_COMMAND_ID);
}

static void zclLockLockCommand(void) {
  zclSimpleClientCommand( ZCL_DOOR_LOCK_CLUSTER_ID,
                          ZCL_LOCK_DOOR_COMMAND_ID);
}

static void zclLockSetHolidayScheduleCommand(void) {
  zclSimpleClientCommand( ZCL_DOOR_LOCK_CLUSTER_ID,
                          ZCL_SET_HOLIDAY_SCHEDULE_COMMAND_ID);
}

static void zclLockSetPinCommand(void) {
  zclSimpleClientCommand( ZCL_DOOR_LOCK_CLUSTER_ID,
                          ZCL_SET_PIN_COMMAND_ID);
}

static void zclLockSetRfidCommand(void) {
  zclSimpleClientCommand( ZCL_DOOR_LOCK_CLUSTER_ID,
                          ZCL_SET_RFID_COMMAND_ID);
}

static void zclLockSetUserTypeCommand(void) {
  zclSimpleClientCommand( ZCL_DOOR_LOCK_CLUSTER_ID,
                          ZCL_SET_USER_TYPE_COMMAND_ID);
}

static void zclLockSetWeekdayScheduleCommand(void) {
  zclSimpleClientCommand( ZCL_DOOR_LOCK_CLUSTER_ID,
                          ZCL_SET_WEEKDAY_SCHEDULE_COMMAND_ID);
}

static void zclLockSetYeardayScheduleCommand(void) {
  zclSimpleClientCommand( ZCL_DOOR_LOCK_CLUSTER_ID,
                          ZCL_SET_YEARDAY_SCHEDULE_COMMAND_ID);
}

static void zclLockUnlockCommand(void) {
  zclSimpleClientCommand( ZCL_DOOR_LOCK_CLUSTER_ID,
                          ZCL_UNLOCK_DOOR_COMMAND_ID);
}

static void zclLockUnlockWithTimeoutCommand(void) {
  zclSimpleClientCommand( ZCL_DOOR_LOCK_CLUSTER_ID,
                          ZCL_UNLOCK_WITH_TIMEOUT_COMMAND_ID);
}

static void zclMeteringChgSupplyCommand(void) {
  zclSimpleClientCommand( ZCL_SIMPLE_METERING_CLUSTER_ID,
                          ZCL_CHANGE_SUPPLY_COMMAND_ID);
}

static void zclMeteringGetProfileCommand(void) {
  zclSimpleClientCommand( ZCL_SIMPLE_METERING_CLUSTER_ID,
                          ZCL_GET_PROFILE_COMMAND_ID);
}

static void zclMeteringGetSampledDataCommand(void) {
  zclSimpleClientCommand( ZCL_SIMPLE_METERING_CLUSTER_ID,
                          ZCL_GET_SAMPLED_DATA_COMMAND_ID);
}

static void zclMeteringGetSnapshotCommand(void) {
  zclSimpleClientCommand( ZCL_SIMPLE_METERING_CLUSTER_ID,
                          ZCL_GET_SNAPSHOT_COMMAND_ID);
}

static void zclMeteringLocalChgSupplyCommand(void) {
  zclSimpleClientCommand( ZCL_SIMPLE_METERING_CLUSTER_ID,
                          ZCL_LOCAL_CHANGE_SUPPLY_COMMAND_ID);
}

static void zclMeteringMirrorRemovedCommand(void) {
  zclSimpleClientCommand( ZCL_SIMPLE_METERING_CLUSTER_ID,
                          ZCL_MIRROR_REMOVED_COMMAND_ID);
}

static void zclMeteringReqFastPollModeCommand(void) {
  zclSimpleClientCommand( ZCL_SIMPLE_METERING_CLUSTER_ID,
                          ZCL_REQUEST_FAST_POLL_MODE_COMMAND_ID);
}

static void zclMeteringRstLoadLimitCtrCommand(void) {
  zclSimpleClientCommand( ZCL_SIMPLE_METERING_CLUSTER_ID,
                          ZCL_RESET_LOAD_LIMIT_COUNTER_COMMAND_ID);
}

static void zclMeteringSchSnapshotCommand(void) {
  zclSimpleClientCommand( ZCL_SIMPLE_METERING_CLUSTER_ID,
                          ZCL_SCHEDULE_SNAPSHOT_COMMAND_ID);
}

static void zclMeteringSetSupplyStatusCommand(void) {
  zclSimpleClientCommand( ZCL_SIMPLE_METERING_CLUSTER_ID,
                          ZCL_SET_SUPPLY_STATUS_COMMAND_ID);
}

static void zclMeteringSetUncntrlFlowThresholdCommand(void) {
  zclSimpleClientCommand( ZCL_SIMPLE_METERING_CLUSTER_ID,
                          ZCL_SET_UNCONTROLLED_FLOW_THRESHOLD_COMMAND_ID);
}

static void zclMeteringStartSamplingCommand(void) {
  zclSimpleClientCommand( ZCL_SIMPLE_METERING_CLUSTER_ID,
                          ZCL_START_SAMPLING_COMMAND_ID);
}

static void zclMeteringTakeSnapshotCommand(void) {
  zclSimpleClientCommand( ZCL_SIMPLE_METERING_CLUSTER_ID,
                          ZCL_TAKE_SNAPSHOT_COMMAND_ID);
}

void zclMfgCodeCommand(void);
static void zclMfglibRxModeCommand(void) {
  zclSimpleClientCommand( ZCL_MFGLIB_CLUSTER_ID,
                          ZCL_RX_MODE_COMMAND_ID);
}

static void zclMfglibStreamCommand(void) {
  zclSimpleClientCommand( ZCL_MFGLIB_CLUSTER_ID,
                          ZCL_STREAM_COMMAND_ID);
}

static void zclMfglibToneCommand(void) {
  zclSimpleClientCommand( ZCL_MFGLIB_CLUSTER_ID,
                          ZCL_TONE_COMMAND_ID);
}

static void zclOnOffOffCommand(void) {
  zclSimpleClientCommand( ZCL_ON_OFF_CLUSTER_ID,
                          ZCL_OFF_COMMAND_ID);
}

static void zclOnOffOffeffectCommand(void) {
  zclSimpleClientCommand( ZCL_ON_OFF_CLUSTER_ID,
                          ZCL_OFF_WITH_EFFECT_COMMAND_ID);
}

static void zclOnOffOnCommand(void) {
  zclSimpleClientCommand( ZCL_ON_OFF_CLUSTER_ID,
                          ZCL_ON_COMMAND_ID);
}

static void zclOnOffOnrecallCommand(void) {
  zclSimpleClientCommand( ZCL_ON_OFF_CLUSTER_ID,
                          ZCL_ON_WITH_RECALL_GLOBAL_SCENE_COMMAND_ID);
}

static void zclOnOffOntimedoffCommand(void) {
  zclSimpleClientCommand( ZCL_ON_OFF_CLUSTER_ID,
                          ZCL_ON_WITH_TIMED_OFF_COMMAND_ID);
}

static void zclOnOffToggleCommand(void) {
  zclSimpleClientCommand( ZCL_ON_OFF_CLUSTER_ID,
                          ZCL_TOGGLE_COMMAND_ID);
}

static void zclOtaConfigLockCommand(void) {
  zclSimpleClientCommand( ZCL_OTA_CONFIGURATION_CLUSTER_ID,
                          ZCL_LOCK_TOKENS_COMMAND_ID);
}

static void zclOtaConfigReadCommand(void) {
  zclSimpleClientCommand( ZCL_OTA_CONFIGURATION_CLUSTER_ID,
                          ZCL_READ_TOKENS_COMMAND_ID);
}

static void zclOtaConfigSetTokenCommand(void) {
  zclSimpleClientCommand( ZCL_OTA_CONFIGURATION_CLUSTER_ID,
                          ZCL_SET_TOKEN_COMMAND_ID);
}

static void zclOtaConfigUnlockCommand(void) {
  zclSimpleClientCommand( ZCL_OTA_CONFIGURATION_CLUSTER_ID,
                          ZCL_UNLOCK_TOKENS_COMMAND_ID);
}

static void zclPollControlLongCommand(void) {
  zclSimpleClientCommand( ZCL_POLL_CONTROL_CLUSTER_ID,
                          ZCL_SET_LONG_POLL_INTERVAL_COMMAND_ID);
}

static void zclPollControlShortCommand(void) {
  zclSimpleClientCommand( ZCL_POLL_CONTROL_CLUSTER_ID,
                          ZCL_SET_SHORT_POLL_INTERVAL_COMMAND_ID);
}

static void zclPollControlStopCommand(void) {
  zclSimpleClientCommand( ZCL_POLL_CONTROL_CLUSTER_ID,
                          ZCL_FAST_POLL_STOP_COMMAND_ID);
}

static void zclScenesAddCommand(void) {
  zclSimpleClientCommand( ZCL_SCENES_CLUSTER_ID,
                          ZCL_ADD_SCENE_COMMAND_ID);
}

static void zclScenesCopyCommand(void) {
  zclSimpleClientCommand( ZCL_SCENES_CLUSTER_ID,
                          ZCL_COPY_SCENE_COMMAND_ID);
}

static void zclScenesEaddCommand(void) {
  zclSimpleClientCommand( ZCL_SCENES_CLUSTER_ID,
                          ZCL_ENHANCED_ADD_SCENE_COMMAND_ID);
}

static void zclScenesEviewCommand(void) {
  zclSimpleClientCommand( ZCL_SCENES_CLUSTER_ID,
                          ZCL_ENHANCED_VIEW_SCENE_COMMAND_ID);
}

static void zclScenesGetCommand(void) {
  zclSimpleClientCommand( ZCL_SCENES_CLUSTER_ID,
                          ZCL_GET_SCENE_MEMBERSHIP_COMMAND_ID);
}

static void zclScenesRecallCommand(void) {
  zclSimpleClientCommand( ZCL_SCENES_CLUSTER_ID,
                          ZCL_RECALL_SCENE_COMMAND_ID);
}

static void zclScenesRemoveCommand(void) {
  zclSimpleClientCommand( ZCL_SCENES_CLUSTER_ID,
                          ZCL_REMOVE_SCENE_COMMAND_ID);
}

static void zclScenesRmallCommand(void) {
  zclSimpleClientCommand( ZCL_SCENES_CLUSTER_ID,
                          ZCL_REMOVE_ALL_SCENES_COMMAND_ID);
}

static void zclScenesStoreCommand(void) {
  zclSimpleClientCommand( ZCL_SCENES_CLUSTER_ID,
                          ZCL_STORE_SCENE_COMMAND_ID);
}

static void zclScenesViewCommand(void) {
  zclSimpleClientCommand( ZCL_SCENES_CLUSTER_ID,
                          ZCL_VIEW_SCENE_COMMAND_ID);
}

void zclTestResponseOffCommand(void);
void zclTestResponseOnCommand(void);
void zclTimeCommand(void);
static void zclTstatCwsCommand(void) {
  zclSimpleClientCommand( ZCL_THERMOSTAT_CLUSTER_ID,
                          ZCL_CLEAR_WEEKLY_SCHEDULE_COMMAND_ID);
}

static void zclTstatGrsCommand(void) {
  zclSimpleClientCommand( ZCL_THERMOSTAT_CLUSTER_ID,
                          ZCL_GET_RELAY_STATUS_LOG_COMMAND_ID);
}

static void zclTstatGwsCommand(void) {
  zclSimpleClientCommand( ZCL_THERMOSTAT_CLUSTER_ID,
                          ZCL_GET_WEEKLY_SCHEDULE_COMMAND_ID);
}

static void zclTstatSetCommand(void) {
  zclSimpleClientCommand( ZCL_THERMOSTAT_CLUSTER_ID,
                          ZCL_SETPOINT_RAISE_LOWER_COMMAND_ID);
}

static void zclTstatSwsCommand(void) {
  zclSimpleClientCommand( ZCL_THERMOSTAT_CLUSTER_ID,
                          ZCL_SET_WEEKLY_SCHEDULE_COMMAND_ID);
}

void zclUseNextSequenceCommand(void);
static void zclWindowCoveringDownCommand(void) {
  zclSimpleClientCommand( ZCL_WINDOW_COVERING_CLUSTER_ID,
                          ZCL_WINDOW_COVERING_DOWN_CLOSE_COMMAND_ID);
}

static void zclWindowCoveringGoToLiftPercentCommand(void) {
  zclSimpleClientCommand( ZCL_WINDOW_COVERING_CLUSTER_ID,
                          ZCL_WINDOW_COVERING_GO_TO_LIFT_PERCENTAGE_COMMAND_ID);
}

static void zclWindowCoveringGoToLiftValueCommand(void) {
  zclSimpleClientCommand( ZCL_WINDOW_COVERING_CLUSTER_ID,
                          ZCL_WINDOW_COVERING_GO_TO_LIFT_VALUE_COMMAND_ID);
}

static void zclWindowCoveringGoToTiltPercentageCommand(void) {
  zclSimpleClientCommand( ZCL_WINDOW_COVERING_CLUSTER_ID,
                          ZCL_WINDOW_COVERING_GO_TO_TILT_PERCENTAGE_COMMAND_ID);
}

static void zclWindowCoveringGoToTiltValueCommand(void) {
  zclSimpleClientCommand( ZCL_WINDOW_COVERING_CLUSTER_ID,
                          ZCL_WINDOW_COVERING_GO_TO_TILT_VALUE_COMMAND_ID);
}

static void zclWindowCoveringStopCommand(void) {
  zclSimpleClientCommand( ZCL_WINDOW_COVERING_CLUSTER_ID,
                          ZCL_WINDOW_COVERING_STOP_COMMAND_ID);
}

static void zclWindowCoveringUpCommand(void) {
  zclSimpleClientCommand( ZCL_WINDOW_COVERING_CLUSTER_ID,
                          ZCL_WINDOW_COVERING_UP_OPEN_COMMAND_ID);
}

void zclXDefaultRespCommand(void);
void zdoActiveEpCommand(void);
void zdoAddClusterCommand(void);
void zdoBindCommand(void);
void zdoClearClusterCommand(void);
void zdoIeeeAddressRequestCommand(void);
void zdoLeaveRequestCommand(void);
void zdoMatchCommand(void);
void zdoMgmtBindCommand(void);
void zdoMgmtLqiCommand(void);
void zdoNetworkUpdateChannelCommand(void);
void zdoNetworkUpdateScanCommand(void);
void zdoNetworkUpdateSetCommand(void);
void zdoNodeCommand(void);
void zdoNwkAddressRequestCommand(void);
void zdoPowerDescriptorRequestCommand(void);
void zdoRouteRequestCommand(void);
void zdoSimpleCommand(void);
void zdoUnbindGroupCommand(void);
void zdoUnbindUnicastCommand(void);
#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZdoUnbindGroupCommandArguments[] = {
  "Target node ID",
  "The source EUI64 of the binding (the remote device's EUI64)",
  "The source endpoint of the binding.",
  "The cluster ID to unbind.",
  "The group address in the binding",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZdoUnbindUnicastCommandArguments[] = {
  "Target node ID",
  "The source EUI64 of the binding (the remote device's EUI64)",
  "The source endpoint of the binding.",
  "The cluster ID to unbind.",
  "The destination EUI64 in the binding (usually the local node's EUI64",
  "The destination endpoint of the binding",
  NULL
};
#endif

static EmberCommandEntry emberCommandTableZdoUnbindCommands[] = {
  emberCommandEntryActionWithDetails("group", zdoUnbindGroupCommand, "vbuvv", "Sends an unbind request for a multicast binding to the target device.", emberCommandTableZdoUnbindGroupCommandArguments),
  emberCommandEntryActionWithDetails("unicast", zdoUnbindUnicastCommand, "vbuvbu", "Sends an unbind request for a unicast binding to the target device.", emberCommandTableZdoUnbindUnicastCommandArguments),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZdoOutClListAddCommandArguments[] = {
  "Client cluster ids",
  NULL
};
#endif

static EmberCommandEntry emberCommandTableZdoOutClListCommands[] = {
  emberCommandEntryActionWithDetails("add", zdoAddClusterCommand, "v", "Add clusters to the known client (out) clusters on this device.", emberCommandTableZdoOutClListAddCommandArguments),
  emberCommandEntryActionWithDetails("clear", zdoClearClusterCommand, "", "Clear the ZDO list of client (out) clusters.", NULL),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZdoNwkUpdChanCommandArguments[] = {
  "One byte channel to change to.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZdoNwkUpdChanPgCommandArguments[] = {
  "One byte channel to change to.",
  "One byte page to change to.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZdoNwkUpdScanCommandArguments[] = {
  "Two byte short id of the target device",
  "One byte scan duration. Must be in range 0 - 5",
  "Number of scans to perform. Must be in range 1 - 8",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZdoNwkUpdScanChanMaskCommandArguments[] = {
  "Two byte short id of the target device",
  "One byte scan duration. Must be in range 0 - 5",
  "Number of scans to perform. Must be in range 1 - 8",
  "Four byte channel mask",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZdoNwkUpdSetCommandArguments[] = {
  "Two byte network manager id",
  "Four byte channel mask",
  NULL
};
#endif

static EmberCommandEntry emberCommandTableZdoNwkUpdCommands[] = {
  emberCommandEntryActionWithDetails("chan", zdoNetworkUpdateChannelCommand, "u", "Sends an update channel request.", emberCommandTableZdoNwkUpdChanCommandArguments),
  emberCommandEntryActionWithDetails("chanPg", zdoNetworkUpdateChannelCommand, "uu", "Sends an update channel page reques ...", emberCommandTableZdoNwkUpdChanPgCommandArguments),
  emberCommandEntryActionWithDetails("scan", zdoNetworkUpdateScanCommand, "vuv", "Performs an energy scan.", emberCommandTableZdoNwkUpdScanCommandArguments),
  emberCommandEntryActionWithDetails("scan-chan-mask", zdoNetworkUpdateScanCommand, "vuvw", "Performs an energy scan on given channel mas ...", emberCommandTableZdoNwkUpdScanChanMaskCommandArguments),
  emberCommandEntryActionWithDetails("set", zdoNetworkUpdateSetCommand, "vw", "Broadcasts the ID of the new network manager and active channels.", emberCommandTableZdoNwkUpdSetCommandArguments),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZdoInClListAddCommandArguments[] = {
  "Server cluster id",
  NULL
};
#endif

static EmberCommandEntry emberCommandTableZdoInClListCommands[] = {
  emberCommandEntryActionWithDetails("add", zdoAddClusterCommand, "v", "Add clusters to the known server (in) clusters on this device.", emberCommandTableZdoInClListAddCommandArguments),
  emberCommandEntryActionWithDetails("clear", zdoClearClusterCommand, "", "Clear the ZDO list of server (in) clusters.", NULL),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZdoActiveCommandArguments[] = {
  "Two byte short id, destination for the active endpoint request",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZdoBindCommandArguments[] = {
  "Two byte destination node id",
  "Remote device's source endpoint to bind",
  "Remote endpoint to bind",
  "Cluster on which to bind",
  "Remote node EUI64",
  "Binding's dest EUI64.  Usually the local node's EUI64",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZdoIeeeCommandArguments[] = {
  "Short address of the device for which a long address is requested",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZdoLeaveCommandArguments[] = {
  "Target node ID",
  "Remove children",
  "Rejoin after leave",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZdoMatchCommandArguments[] = {
  "Two byte node id indicating wher",
  "Two byte profile id for the match descriptor request",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZdoMgmtBindCommandArguments[] = {
  "Target node ID",
  "Starting index into table query",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZdoMgmtLqiCommandArguments[] = {
  "Target node ID",
  "Starting index into table query",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZdoNodeCommandArguments[] = {
  "Two byte address for the target device.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZdoNwkCommandArguments[] = {
  "IEEE address for which a short address is being requested",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZdoPowerCommandArguments[] = {
  "Target node ID",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZdoRouteCommandArguments[] = {
  "Target node ID",
  "The index of the remote node's routing table to request.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZdoSimpleCommandArguments[] = {
  "Short address of the device where the simple descriptor request should ...",
  "The endpoint on the target device where the simple descriptor request  ...",
  NULL
};
#endif

static EmberCommandEntry emberCommandTableZdoCommands[] = {
  emberCommandEntryActionWithDetails("active", zdoActiveEpCommand, "v", "Send an active endpoint request to the device with the given short id.", emberCommandTableZdoActiveCommandArguments),
  emberCommandEntryActionWithDetails("bind", zdoBindCommand, "vuuvbb", "Send a ZDO Bind command to a device specified in the command arguments ...", emberCommandTableZdoBindCommandArguments),
  emberCommandEntryActionWithDetails("ieee", zdoIeeeAddressRequestCommand, "v", "Request an ieee address based on a given node id.", emberCommandTableZdoIeeeCommandArguments),
  emberCommandEntrySubMenu("in-cl-list", emberCommandTableZdoInClListCommands, ""),
  emberCommandEntryActionWithDetails("leave", zdoLeaveRequestCommand, "vuu", "Send a ZDO Management Leave command to the target device.", emberCommandTableZdoLeaveCommandArguments),
  emberCommandEntryActionWithDetails("match", zdoMatchCommand, "vv", "Sends a matchDescriptorsRequest to the given destination with the give ...", emberCommandTableZdoMatchCommandArguments),
  emberCommandEntryActionWithDetails("mgmt-bind", zdoMgmtBindCommand, "vu", "Send a ZDO MGMT-Bind (Binding Table) Request to the target device.", emberCommandTableZdoMgmtBindCommandArguments),
  emberCommandEntryActionWithDetails("mgmt-lqi", zdoMgmtLqiCommand, "vu", "Send a ZDO MGMT-LQI (LQI Table) Request to the target device.", emberCommandTableZdoMgmtLqiCommandArguments),
  emberCommandEntryActionWithDetails("node", zdoNodeCommand, "v", "Sends a node descriptor request to a given target device", emberCommandTableZdoNodeCommandArguments),
  emberCommandEntryActionWithDetails("nwk", zdoNwkAddressRequestCommand, "b", "Sends a network address request for the given IEEE address.", emberCommandTableZdoNwkCommandArguments),
  emberCommandEntrySubMenu("nwk-upd", emberCommandTableZdoNwkUpdCommands, ""),
  emberCommandEntrySubMenu("out-cl-list", emberCommandTableZdoOutClListCommands, ""),
  emberCommandEntryActionWithDetails("power", zdoPowerDescriptorRequestCommand, "v", "Send a ZDO Power Descriptor Request to the target device.", emberCommandTableZdoPowerCommandArguments),
  emberCommandEntryActionWithDetails("route", zdoRouteRequestCommand, "vu", "Send a ZDO route request command to the target.", emberCommandTableZdoRouteCommandArguments),
  emberCommandEntryActionWithDetails("simple", zdoSimpleCommand, "vu", "Sends out a simple descriptor request for the short address and endpoi ...", emberCommandTableZdoSimpleCommandArguments),
  emberCommandEntrySubMenu("unbind", emberCommandTableZdoUnbindCommands, ""),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclWindowCoveringGoToLiftPercentCommandArguments[] = {
  "percentage lift value",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclWindowCoveringGoToLiftValueCommandArguments[] = {
  "lift value",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclWindowCoveringGoToTiltPercentageCommandArguments[] = {
  "percentage tilt value",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclWindowCoveringGoToTiltValueCommandArguments[] = {
  "tilt value",
  NULL
};
#endif

static EmberCommandEntry emberCommandTableZclWindowCoveringCommands[] = {
  emberCommandEntryActionWithDetails("down", zclWindowCoveringDownCommand, "", "Moves window covering to InstalledClosedLimit - Lift and InstalledClos ...", NULL),
  emberCommandEntryActionWithDetails("go-to-lift-percent", zclWindowCoveringGoToLiftPercentCommand, "u", "Goto lift percentage specified", emberCommandTableZclWindowCoveringGoToLiftPercentCommandArguments),
  emberCommandEntryActionWithDetails("go-to-lift-value", zclWindowCoveringGoToLiftValueCommand, "v", "Goto lift value specified", emberCommandTableZclWindowCoveringGoToLiftValueCommandArguments),
  emberCommandEntryActionWithDetails("go-to-tilt-percentage", zclWindowCoveringGoToTiltPercentageCommand, "u", "Goto tilt percentage specified", emberCommandTableZclWindowCoveringGoToTiltPercentageCommandArguments),
  emberCommandEntryActionWithDetails("go-to-tilt-value", zclWindowCoveringGoToTiltValueCommand, "v", "Goto tilt value specified", emberCommandTableZclWindowCoveringGoToTiltValueCommandArguments),
  emberCommandEntryActionWithDetails("stop", zclWindowCoveringStopCommand, "", "Stop any adjusting of window covering", NULL),
  emberCommandEntryActionWithDetails("up", zclWindowCoveringUpCommand, "", "Moves window covering to InstalledOpenLimit - Lift and InstalledOpenLi ...", NULL),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclTstatGwsCommandArguments[] = {
  "days to return",
  "mode to return",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclTstatSetCommandArguments[] = {
  "mode",
  "amount",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclTstatSwsCommandArguments[] = {
  "number of transitions for sequence",
  "day of week for sequence",
  "mode for sequence",
  "payload",
  "",
  NULL
};
#endif

static EmberCommandEntry emberCommandTableZclTstatCommands[] = {
  emberCommandEntryActionWithDetails("cws", zclTstatCwsCommand, "", "The Clear Weekly Schedule command is used to clear the weekly schedule ...", NULL),
  emberCommandEntryActionWithDetails("grs", zclTstatGrsCommand, "", "The Get Relay Status Log command is used to query the thermostat inter ...", NULL),
  emberCommandEntryActionWithDetails("gws", zclTstatGwsCommand, "uu", "Command description for GetWeeklySchedule", emberCommandTableZclTstatGwsCommandArguments),
  emberCommandEntryActionWithDetails("set", zclTstatSetCommand, "us", "Command description for SetpointRaiseLower", emberCommandTableZclTstatSetCommandArguments),
  emberCommandEntryActionWithDetails("sws", zclTstatSwsCommand, "uuuu*", "Command description for SetWeeklySchedule", emberCommandTableZclTstatSwsCommandArguments),
  emberCommandEntryTerminator()
};

static EmberCommandEntry emberCommandTableZclTestResponseCommands[] = {
  emberCommandEntryActionWithDetails("off", zclTestResponseOffCommand, "", "Sets a flag so that the application framework WILL NOT respond to the  ...", NULL),
  emberCommandEntryActionWithDetails("on", zclTestResponseOnCommand, "", "Sets a flag so that the application framework WILL respond to the next ...", NULL),
  emberCommandEntryTerminator()
};

static EmberCommandEntry emberCommandTableZclTestCommands[] = {
  emberCommandEntrySubMenu("response", emberCommandTableZclTestResponseCommands, ""),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclScenesAddCommandArguments[] = {
  "group id",
  "scene id",
  "transition time",
  "scene name",
  "extension field sets",
  "",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclScenesCopyCommandArguments[] = {
  "mode",
  "group id from",
  "scene id from",
  "group id to",
  "scene id to",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclScenesEaddCommandArguments[] = {
  "group id",
  "scene id",
  "transition time",
  "scene name",
  "extension field sets",
  "",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclScenesEviewCommandArguments[] = {
  "group id",
  "scene id",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclScenesGetCommandArguments[] = {
  "group id",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclScenesRecallCommandArguments[] = {
  "group id",
  "scene id",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclScenesRemoveCommandArguments[] = {
  "group id",
  "scene id",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclScenesRmallCommandArguments[] = {
  "group id",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclScenesStoreCommandArguments[] = {
  "group id",
  "scene id",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclScenesViewCommandArguments[] = {
  "group id",
  "scene id",
  NULL
};
#endif

static EmberCommandEntry emberCommandTableZclScenesCommands[] = {
  emberCommandEntryActionWithDetails("add", zclScenesAddCommand, "vuvbw*", "Add a scene to the scene tabl ...", emberCommandTableZclScenesAddCommandArguments),
  emberCommandEntryActionWithDetails("copy", zclScenesCopyCommand, "uvuvu", "Command description for CopyScene", emberCommandTableZclScenesCopyCommandArguments),
  emberCommandEntryActionWithDetails("eadd", zclScenesEaddCommand, "vuvbw*", "Command description for EnhancedAddScene", emberCommandTableZclScenesEaddCommandArguments),
  emberCommandEntryActionWithDetails("eview", zclScenesEviewCommand, "vu", "Command description for EnhancedViewScene", emberCommandTableZclScenesEviewCommandArguments),
  emberCommandEntryActionWithDetails("get", zclScenesGetCommand, "v", "Command description for GetSceneMembership", emberCommandTableZclScenesGetCommandArguments),
  emberCommandEntryActionWithDetails("recall", zclScenesRecallCommand, "vu", "Command description for RecallScene", emberCommandTableZclScenesRecallCommandArguments),
  emberCommandEntryActionWithDetails("remove", zclScenesRemoveCommand, "vu", "Command description for RemoveScene", emberCommandTableZclScenesRemoveCommandArguments),
  emberCommandEntryActionWithDetails("rmall", zclScenesRmallCommand, "v", "Command description for RemoveAllScenes", emberCommandTableZclScenesRmallCommandArguments),
  emberCommandEntryActionWithDetails("store", zclScenesStoreCommand, "vu", "Command description for StoreScene", emberCommandTableZclScenesStoreCommandArguments),
  emberCommandEntryActionWithDetails("view", zclScenesViewCommand, "vu", "Command description for ViewScene", emberCommandTableZclScenesViewCommandArguments),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclPollControlLongCommandArguments[] = {
  "new long poll interval",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclPollControlShortCommandArguments[] = {
  "new short poll interval",
  NULL
};
#endif

static EmberCommandEntry emberCommandTableZclPollControlCommands[] = {
  emberCommandEntryActionWithDetails("long", zclPollControlLongCommand, "w", "The Set Long Poll Interval command is used to set the read only Long P ...", emberCommandTableZclPollControlLongCommandArguments),
  emberCommandEntryActionWithDetails("short", zclPollControlShortCommand, "v", "The Set Short Poll Interval command is used to set the read only Short ...", emberCommandTableZclPollControlShortCommandArguments),
  emberCommandEntryActionWithDetails("stop", zclPollControlStopCommand, "", "The Fast Poll Stop command is used to stop the fast poll mode initiate ...", NULL),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclOtaConfigReadCommandArguments[] = {
  "token",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclOtaConfigSetTokenCommandArguments[] = {
  "token",
  "data",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclOtaConfigUnlockCommandArguments[] = {
  "data",
  NULL
};
#endif

static EmberCommandEntry emberCommandTableZclOtaConfigCommands[] = {
  emberCommandEntryActionWithDetails("lock", zclOtaConfigLockCommand, "", "Command to lock the token values.", NULL),
  emberCommandEntryActionWithDetails("read", zclOtaConfigReadCommand, "v", "Command to read a token value.", emberCommandTableZclOtaConfigReadCommandArguments),
  emberCommandEntryActionWithDetails("setToken", zclOtaConfigSetTokenCommand, "vb", "Command to write a token value over the air.", emberCommandTableZclOtaConfigSetTokenCommandArguments),
  emberCommandEntryActionWithDetails("unlock", zclOtaConfigUnlockCommand, "b", "Command to unlock tokens with a device-specific password (if allowed).", emberCommandTableZclOtaConfigUnlockCommandArguments),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclOnOffOffeffectCommandArguments[] = {
  "effect id",
  "effect variant",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclOnOffOntimedoffCommandArguments[] = {
  "on off control",
  "on time",
  "off wait time",
  NULL
};
#endif

static EmberCommandEntry emberCommandTableZclOnOffCommands[] = {
  emberCommandEntryActionWithDetails("off", zclOnOffOffCommand, "", "Command description for Off", NULL),
  emberCommandEntryActionWithDetails("offeffect", zclOnOffOffeffectCommand, "uu", "Command description for OffWithEffect", emberCommandTableZclOnOffOffeffectCommandArguments),
  emberCommandEntryActionWithDetails("on", zclOnOffOnCommand, "", "Command description for On", NULL),
  emberCommandEntryActionWithDetails("onrecall", zclOnOffOnrecallCommand, "", "Command description for OnWithRecallGlobalScene", NULL),
  emberCommandEntryActionWithDetails("ontimedoff", zclOnOffOntimedoffCommand, "uvv", "Command description for OnWithTimedOff", emberCommandTableZclOnOffOntimedoffCommandArguments),
  emberCommandEntryActionWithDetails("toggle", zclOnOffToggleCommand, "", "Command description for Toggle", NULL),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclMfglibRxModeCommandArguments[] = {
  "channel",
  "power",
  "time",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclMfglibStreamCommandArguments[] = {
  "channel",
  "power",
  "time",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclMfglibToneCommandArguments[] = {
  "channel",
  "power",
  "time",
  NULL
};
#endif

static EmberCommandEntry emberCommandTableZclMfglibCommands[] = {
  emberCommandEntryActionWithDetails("rx-mode", zclMfglibRxModeCommand, "usv", "Command to put the device into RX mode.", emberCommandTableZclMfglibRxModeCommandArguments),
  emberCommandEntryActionWithDetails("stream", zclMfglibStreamCommand, "usv", "Command to put the device into streaming mode.", emberCommandTableZclMfglibStreamCommandArguments),
  emberCommandEntryActionWithDetails("tone", zclMfglibToneCommand, "usv", "Command to put the device into tone mode.", emberCommandTableZclMfglibToneCommandArguments),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclMeteringChgSupplyCommandArguments[] = {
  "provider id",
  "issuer event id",
  "request date time",
  "implementation date time",
  "proposed supply status",
  "supply control bits",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclMeteringGetProfileCommandArguments[] = {
  "interval channel",
  "end time",
  "number of periods",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclMeteringGetSampledDataCommandArguments[] = {
  "sample id",
  "earliest sample time",
  "sample type",
  "number of samples",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclMeteringGetSnapshotCommandArguments[] = {
  "earliest start time",
  "latest end time",
  "snapshot offset",
  "snapshot cause",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclMeteringLocalChgSupplyCommandArguments[] = {
  "proposed supply status",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclMeteringMirrorRemovedCommandArguments[] = {
  "endpoint id",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclMeteringReqFastPollModeCommandArguments[] = {
  "fast poll update period",
  "duration",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclMeteringRstLoadLimitCtrCommandArguments[] = {
  "provider id",
  "issuer event id",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclMeteringSchSnapshotCommandArguments[] = {
  "issuer event id",
  "command index",
  "command count",
  "snapshot schedule payload",
  "",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclMeteringSetSupplyStatusCommandArguments[] = {
  "issuer event id",
  "supply tamper state",
  "supply depletion state",
  "supply uncontrolled flow state",
  "load limit supply state",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclMeteringSetUncntrlFlowThresholdCommandArguments[] = {
  "provider id",
  "issuer event id",
  "uncontrolled flow threshold",
  "unit of measure",
  "multiplier",
  "divisor",
  "stabilisation period",
  "measurement period",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclMeteringStartSamplingCommandArguments[] = {
  "issuer event id",
  "start sampling time",
  "sample type",
  "sample request interval",
  "max number of samples",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclMeteringTakeSnapshotCommandArguments[] = {
  "snapshot cause",
  NULL
};
#endif

static EmberCommandEntry emberCommandTableZclMeteringCommands[] = {
  emberCommandEntryActionWithDetails("chg-supply", zclMeteringChgSupplyCommand, "wwwwuu", "This command is sent from the Head-end or ESI to the Metering Device t ...", emberCommandTableZclMeteringChgSupplyCommandArguments),
  emberCommandEntryActionWithDetails("get-profile", zclMeteringGetProfileCommand, "uwu", "The GetProfile command is generated when a client device wishes to ret ...", emberCommandTableZclMeteringGetProfileCommandArguments),
  emberCommandEntryActionWithDetails("get-sampled-data", zclMeteringGetSampledDataCommand, "vwuv", "This command is used to request sampled data from the serve ...", emberCommandTableZclMeteringGetSampledDataCommandArguments),
  emberCommandEntryActionWithDetails("get-snapshot", zclMeteringGetSnapshotCommand, "wwuw", "This command is used to request snapshot data from the cluster server.", emberCommandTableZclMeteringGetSnapshotCommandArguments),
  emberCommandEntryActionWithDetails("local-chg-supply", zclMeteringLocalChgSupplyCommand, "u", "This command is a simplified version of the ChangeSupply command, inte ...", emberCommandTableZclMeteringLocalChgSupplyCommandArguments),
  emberCommandEntryActionWithDetails("mirror-removed", zclMeteringMirrorRemovedCommand, "v", "The Mirror Removed Command allows the ESI to inform a sleepy Metering  ...", emberCommandTableZclMeteringMirrorRemovedCommandArguments),
  emberCommandEntryActionWithDetails("req-fast-poll-mode", zclMeteringReqFastPollModeCommand, "uu", "The Request Fast Poll Mode command is generated when the metering clie ...", emberCommandTableZclMeteringReqFastPollModeCommandArguments),
  emberCommandEntryActionWithDetails("rst-load-limit-ctr", zclMeteringRstLoadLimitCtrCommand, "ww", "The ResetLoadLimitCounter command shall cause the LoadLimitCounter att ...", emberCommandTableZclMeteringRstLoadLimitCtrCommandArguments),
  emberCommandEntryActionWithDetails("sch-snapshot", zclMeteringSchSnapshotCommand, "wuub*", "This command is used to set up a schedule of when the device shall cre ...", emberCommandTableZclMeteringSchSnapshotCommandArguments),
  emberCommandEntryActionWithDetails("set-supply-status", zclMeteringSetSupplyStatusCommand, "wuuuu", "This command is used to specify the required status of the supply foll ...", emberCommandTableZclMeteringSetSupplyStatusCommandArguments),
  emberCommandEntryActionWithDetails("set-uncntrl-flow-threshold", zclMeteringSetUncntrlFlowThresholdCommand, "wwvuvvuv", "This command is used to update the 'Uncontrolled Flow Rate' configurat ...", emberCommandTableZclMeteringSetUncntrlFlowThresholdCommandArguments),
  emberCommandEntryActionWithDetails("start-sampling", zclMeteringStartSamplingCommand, "wwuvv", "The sampling mechanism allows a set of samples of the specified type o ...", emberCommandTableZclMeteringStartSamplingCommandArguments),
  emberCommandEntryActionWithDetails("take-snapshot", zclMeteringTakeSnapshotCommand, "w", "This command is used to instruct the cluster server to take a single s ...", emberCommandTableZclMeteringTakeSnapshotCommandArguments),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclLockClearHolidayScheduleCommandArguments[] = {
  "schedule id",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclLockClearPinCommandArguments[] = {
  "user id",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclLockClearRfidCommandArguments[] = {
  "user id",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclLockClearWeekdayScheduleCommandArguments[] = {
  "schedule id",
  "user id",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclLockClearYeardayScheduleCommandArguments[] = {
  "schedule id",
  "user id",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclLockGetHolidayScheduleCommandArguments[] = {
  "schedule id",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclLockGetLogRecordCommandArguments[] = {
  "log index",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclLockGetPinCommandArguments[] = {
  "user id",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclLockGetRfidCommandArguments[] = {
  "user id",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclLockGetUserTypeCommandArguments[] = {
  "user id",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclLockGetWeekdayScheduleCommandArguments[] = {
  "schedule id",
  "user id",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclLockGetYeardayScheduleCommandArguments[] = {
  "schedule id",
  "user id",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclLockLockCommandArguments[] = {
  "pin",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclLockSetHolidayScheduleCommandArguments[] = {
  "schedule id",
  "local start time",
  "local end time",
  "operating mode during holiday",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclLockSetPinCommandArguments[] = {
  "user id",
  "user status",
  "user type",
  "pin",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclLockSetRfidCommandArguments[] = {
  "user id",
  "user status",
  "user type",
  "id",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclLockSetUserTypeCommandArguments[] = {
  "user id",
  "user type",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclLockSetWeekdayScheduleCommandArguments[] = {
  "schedule id",
  "user id",
  "days mask",
  "start hour",
  "start minute",
  "end hour",
  "end minute",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclLockSetYeardayScheduleCommandArguments[] = {
  "schedule id",
  "user id",
  "local start time",
  "local end time",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclLockUnlockCommandArguments[] = {
  "pin",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclLockUnlockWithTimeoutCommandArguments[] = {
  "timeout in seconds",
  "pin",
  NULL
};
#endif

static EmberCommandEntry emberCommandTableZclLockCommands[] = {
  emberCommandEntryActionWithDetails("clear-all-rfids", zclLockClearAllRfidsCommand, "", "Clear all RFID ID codes on the lock for all users.", NULL),
  emberCommandEntryActionWithDetails("clear-holiday-schedule", zclLockClearHolidayScheduleCommand, "u", "Clear a holiday schedule for a specific scheduleId", emberCommandTableZclLockClearHolidayScheduleCommandArguments),
  emberCommandEntryActionWithDetails("clear-pin", zclLockClearPinCommand, "v", "Clear the PIN for a user with a specific user ID", emberCommandTableZclLockClearPinCommandArguments),
  emberCommandEntryActionWithDetails("clear-rfid", zclLockClearRfidCommand, "v", "Clear the RFID ID for a user with a specific user ID", emberCommandTableZclLockClearRfidCommandArguments),
  emberCommandEntryActionWithDetails("clear-weekday-schedule", zclLockClearWeekdayScheduleCommand, "uv", "Clear a weekday schedule for doorlock user activation for a specific s ...", emberCommandTableZclLockClearWeekdayScheduleCommandArguments),
  emberCommandEntryActionWithDetails("clear-yearday-schedule", zclLockClearYeardayScheduleCommand, "uv", "Clear a yearday schedule for a specific scheduleId and userId", emberCommandTableZclLockClearYeardayScheduleCommandArguments),
  emberCommandEntryActionWithDetails("get-holiday-schedule", zclLockGetHolidayScheduleCommand, "u", "Retrieve a holiday schedule for a specific scheduleId", emberCommandTableZclLockGetHolidayScheduleCommandArguments),
  emberCommandEntryActionWithDetails("get-log-record", zclLockGetLogRecordCommand, "v", "Retrieve a log record at a specified index.", emberCommandTableZclLockGetLogRecordCommandArguments),
  emberCommandEntryActionWithDetails("get-pin", zclLockGetPinCommand, "v", "Retrieve PIN information for a user with a specific user ID.", emberCommandTableZclLockGetPinCommandArguments),
  emberCommandEntryActionWithDetails("get-rfid", zclLockGetRfidCommand, "v", "Retrieve RFID ID information for a user with a specific user ID.", emberCommandTableZclLockGetRfidCommandArguments),
  emberCommandEntryActionWithDetails("get-user-type", zclLockGetUserTypeCommand, "v", "Retrieve the type for a specific user based on the user ID.", emberCommandTableZclLockGetUserTypeCommandArguments),
  emberCommandEntryActionWithDetails("get-weekday-schedule", zclLockGetWeekdayScheduleCommand, "uv", "Retrieve a weekday schedule for doorlock user activation for a specifi ...", emberCommandTableZclLockGetWeekdayScheduleCommandArguments),
  emberCommandEntryActionWithDetails("get-yearday-schedule", zclLockGetYeardayScheduleCommand, "uv", "Retrieve a yearday schedule for a specific scheduleId and userId", emberCommandTableZclLockGetYeardayScheduleCommandArguments),
  emberCommandEntryActionWithDetails("lock", zclLockLockCommand, "b", "Locks the door", emberCommandTableZclLockLockCommandArguments),
  emberCommandEntryActionWithDetails("set-holiday-schedule", zclLockSetHolidayScheduleCommand, "uwwu", "Set the holiday schedule for a specific user", emberCommandTableZclLockSetHolidayScheduleCommandArguments),
  emberCommandEntryActionWithDetails("set-pin", zclLockSetPinCommand, "vuub", "Set the PIN for a specified user id.", emberCommandTableZclLockSetPinCommandArguments),
  emberCommandEntryActionWithDetails("set-rfid", zclLockSetRfidCommand, "vuub", "Set the PIN for a specified user id.", emberCommandTableZclLockSetRfidCommandArguments),
  emberCommandEntryActionWithDetails("set-user-type", zclLockSetUserTypeCommand, "vu", "Set the type value for a user based on user ID.", emberCommandTableZclLockSetUserTypeCommandArguments),
  emberCommandEntryActionWithDetails("set-weekday-schedule", zclLockSetWeekdayScheduleCommand, "uvuuuuu", "Set the schedule of days during the week that the associated user base ...", emberCommandTableZclLockSetWeekdayScheduleCommandArguments),
  emberCommandEntryActionWithDetails("set-yearday-schedule", zclLockSetYeardayScheduleCommand, "uvww", "Set a door lock user id activation schedule according to a specific ab ...", emberCommandTableZclLockSetYeardayScheduleCommandArguments),
  emberCommandEntryActionWithDetails("unlock", zclLockUnlockCommand, "b", "Unlocks the door", emberCommandTableZclLockUnlockCommandArguments),
  emberCommandEntryActionWithDetails("unlock-with-timeout", zclLockUnlockWithTimeoutCommand, "vb", "Unlock the door with a timeou ...", emberCommandTableZclLockUnlockWithTimeoutCommandArguments),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclLevelControlMoveCommandArguments[] = {
  "move mode",
  "rate",
  "option mask",
  "option override",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclLevelControlMvToLevelCommandArguments[] = {
  "level",
  "transition time",
  "option mask",
  "option override",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclLevelControlOMoveCommandArguments[] = {
  "move mode",
  "rate",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclLevelControlOMvToLevelCommandArguments[] = {
  "level",
  "transition time",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclLevelControlOStepCommandArguments[] = {
  "step mode",
  "step size",
  "transition time",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclLevelControlStepCommandArguments[] = {
  "step mode",
  "step size",
  "transition time",
  "option mask",
  "option override",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclLevelControlStopCommandArguments[] = {
  "option mask",
  "option override",
  NULL
};
#endif

static EmberCommandEntry emberCommandTableZclLevelControlCommands[] = {
  emberCommandEntryActionWithDetails("move", zclLevelControlMoveCommand, "uuuu", "Command description for Move", emberCommandTableZclLevelControlMoveCommandArguments),
  emberCommandEntryActionWithDetails("mv-to-level", zclLevelControlMvToLevelCommand, "uvuu", "Command description for MoveToLevel", emberCommandTableZclLevelControlMvToLevelCommandArguments),
  emberCommandEntryActionWithDetails("o-move", zclLevelControlOMoveCommand, "uu", "Command description for MoveWithOnOff", emberCommandTableZclLevelControlOMoveCommandArguments),
  emberCommandEntryActionWithDetails("o-mv-to-level", zclLevelControlOMvToLevelCommand, "uv", "Command description for MoveToLevelWithOnOff", emberCommandTableZclLevelControlOMvToLevelCommandArguments),
  emberCommandEntryActionWithDetails("o-step", zclLevelControlOStepCommand, "uuv", "Command description for StepWithOnOff", emberCommandTableZclLevelControlOStepCommandArguments),
  emberCommandEntryActionWithDetails("o-stop", zclLevelControlOStopCommand, "", "Command description for StopWithOnOff", NULL),
  emberCommandEntryActionWithDetails("step", zclLevelControlStepCommand, "uuvuu", "Command description for Step", emberCommandTableZclLevelControlStepCommandArguments),
  emberCommandEntryActionWithDetails("stop", zclLevelControlStopCommand, "uu", "Command description for Stop", emberCommandTableZclLevelControlStopCommandArguments),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclIdentifyEzModeCommandArguments[] = {
  "action",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclIdentifyIdCommandArguments[] = {
  "identify time",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclIdentifyTriggerCommandArguments[] = {
  "effect id",
  "effect variant",
  NULL
};
#endif

static EmberCommandEntry emberCommandTableZclIdentifyCommands[] = {
  emberCommandEntryActionWithDetails("ez-mode", zclIdentifyEzModeCommand, "u", "Invoke EZMode on an Identify Server", emberCommandTableZclIdentifyEzModeCommandArguments),
  emberCommandEntryActionWithDetails("id", zclIdentifyIdCommand, "v", "Command description for Identify", emberCommandTableZclIdentifyIdCommandArguments),
  emberCommandEntryActionWithDetails("query", zclIdentifyQueryCommand, "", "Command description for IdentifyQuery", NULL),
  emberCommandEntryActionWithDetails("trigger", zclIdentifyTriggerCommand, "uu", "Command description for TriggerEffect", emberCommandTableZclIdentifyTriggerCommandArguments),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclGroupsAddCommandArguments[] = {
  "group id",
  "group name",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclGroupsAddIfIdCommandArguments[] = {
  "group id",
  "group name",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclGroupsGetCommandArguments[] = {
  "group count",
  "group list",
  "",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclGroupsRemoveCommandArguments[] = {
  "group id",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclGroupsViewCommandArguments[] = {
  "group id",
  NULL
};
#endif

static EmberCommandEntry emberCommandTableZclGroupsCommands[] = {
  emberCommandEntryActionWithDetails("add", zclGroupsAddCommand, "vb", "Command description for AddGroup", emberCommandTableZclGroupsAddCommandArguments),
  emberCommandEntryActionWithDetails("add-if-id", zclGroupsAddIfIdCommand, "vb", "Command description for AddGroupIfIdentifying", emberCommandTableZclGroupsAddIfIdCommandArguments),
  emberCommandEntryActionWithDetails("get", zclGroupsGetCommand, "uv*", "Command description for GetGroupMembership", emberCommandTableZclGroupsGetCommandArguments),
  emberCommandEntryActionWithDetails("remove", zclGroupsRemoveCommand, "v", "Command description for RemoveGroup", emberCommandTableZclGroupsRemoveCommandArguments),
  emberCommandEntryActionWithDetails("rmall", zclGroupsRmallCommand, "", "Command description for RemoveAllGroups", NULL),
  emberCommandEntryActionWithDetails("view", zclGroupsViewCommand, "v", "Command description for ViewGroup", emberCommandTableZclGroupsViewCommandArguments),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclGlobalDirectionCommandArguments[] = {
  "The direction for global commands, 0 = client to server, 1 = server to ...",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclGlobalDiscComGenCommandArguments[] = {
  "The cluster to find commands on.",
  "The command id to start the command search on.",
  "Max command ids to search for.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclGlobalDiscComRecCommandArguments[] = {
  "The cluster to find commands on.",
  "The command id to start the command search on.",
  "Max command ids to search for.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclGlobalDiscoverCommandArguments[] = {
  "The cluster id of the cluster to discover.",
  "The attribute id of the attribute to read during discovery.",
  "Max number of discovery responses.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclGlobalExpectReportFromMeCommandArguments[] = {
  "The cluster id for the requested report.",
  "The attribute id for the requested report.",
  "Maximum amount of time between reports.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclGlobalNwriteCommandArguments[] = {
  "The cluster id of the cluster to read from.",
  "The attribute id of the attribute to read.",
  "The type of the attribute to write.",
  "The data to be written.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclGlobalReadCommandArguments[] = {
  "The cluster id of the cluster to read from.",
  "The attribute id of the attribute to read.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclGlobalReportCommandArguments[] = {
  "The desired endpoint.",
  "The cluster id.",
  "The attribute id.",
  "The mask.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclGlobalReportReadCommandArguments[] = {
  "The cluster id to read from.",
  "The attribute id to read from.",
  "0 for client-to-server, 1 for server-to-client.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclGlobalSendMeAReportCommandArguments[] = {
  "The cluster id of the requested report.",
  "The attribute id for requested report.",
  "The two byte ZigBee type value for the requested report.",
  "Minimum number of seconds between reports.",
  "Maximum number of seconds between reports.",
  "Amount of change to trigger a report.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclGlobalUwriteCommandArguments[] = {
  "The cluster id of the cluster to write to.",
  "The attribute id of the attribute to write.",
  "The type of the attribute to write.",
  "The data to be written.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclGlobalWriteCommandArguments[] = {
  "The cluster id of the cluster to write to.",
  "The attribute id of the attribute to write.",
  "The type of the attribute to write.",
  "The data to be written.",
  NULL
};
#endif

static EmberCommandEntry emberCommandTableZclGlobalCommands[] = {
  emberCommandEntryActionWithDetails("direction", zclGlobalDirectionCommand, "u", "Sets the direction for global commands, either client to server or ser ...", emberCommandTableZclGlobalDirectionCommandArguments),
  emberCommandEntryActionWithDetails("disc-com-gen", zclGlobalCommandDiscoveryCommand, "vuu", "Create a Discover Commands Generated command with associated values.", emberCommandTableZclGlobalDiscComGenCommandArguments),
  emberCommandEntryActionWithDetails("disc-com-rec", zclGlobalCommandDiscoveryCommand, "vuu", "Create a Discover Commands Received command with associated values.", emberCommandTableZclGlobalDiscComRecCommandArguments),
  emberCommandEntryActionWithDetails("discover", zclGlobalDiscoverCommand, "vvu", "Creates discovery message for devices with the associated cluster and  ...", emberCommandTableZclGlobalDiscoverCommandArguments),
  emberCommandEntryActionWithDetails("expect-report-from-me", zclGlobalExpectReportFromMeCommand, "vvv", "Create a expect-report-from-me message with associated values.", emberCommandTableZclGlobalExpectReportFromMeCommandArguments),
  emberCommandEntryActionWithDetails("nwrite", zclGlobalWriteCommand, "vvub", "Creates a global write command message to write to the cluster and att ...", emberCommandTableZclGlobalNwriteCommandArguments),
  emberCommandEntryActionWithDetails("read", zclGlobalReadCommand, "vv", "Creates a global read command message to read from the cluster and att ...", emberCommandTableZclGlobalReadCommandArguments),
  emberCommandEntryActionWithDetails("report", zclGlobalReportCommand, "uvvu", "", emberCommandTableZclGlobalReportCommandArguments),
  emberCommandEntryActionWithDetails("report-read", zclGlobalReportReadCommand, "vvu", "Creates a global read reporting command for the associated cluster, at ...", emberCommandTableZclGlobalReportReadCommandArguments),
  emberCommandEntryActionWithDetails("send-me-a-report", zclGlobalSendMeAReportCommand, "vvuvvb", "Creates a global send me a report command for the associated values.", emberCommandTableZclGlobalSendMeAReportCommandArguments),
  emberCommandEntryActionWithDetails("uwrite", zclGlobalWriteCommand, "vvub", "Creates a global write undivided command message to write to the clust ...", emberCommandTableZclGlobalUwriteCommandArguments),
  emberCommandEntryActionWithDetails("write", zclGlobalWriteCommand, "vvwb", "Creates a global write command message to write to the cluster and att ...", emberCommandTableZclGlobalWriteCommandArguments),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclColorControlEmovehueCommandArguments[] = {
  "move mode",
  "rate",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclColorControlEmovetohueCommandArguments[] = {
  "enhanced hue",
  "direction",
  "transition time",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclColorControlEmovetohueandsatCommandArguments[] = {
  "enhanced hue",
  "saturation",
  "transition time",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclColorControlEstephueCommandArguments[] = {
  "step mode",
  "step size",
  "transition time",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclColorControlLoopCommandArguments[] = {
  "update flags",
  "action",
  "direction",
  "time",
  "start hue",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclColorControlMovecolorCommandArguments[] = {
  "rate x",
  "rate y",
  "options mask",
  "options override",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclColorControlMovecolortempCommandArguments[] = {
  "move mode",
  "rate",
  "color temperature minimum",
  "color temperature maximum",
  "options mask",
  "options override",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclColorControlMovehueCommandArguments[] = {
  "move mode",
  "rate",
  "options mask",
  "options override",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclColorControlMovesatCommandArguments[] = {
  "move mode",
  "rate",
  "options mask",
  "options override",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclColorControlMovetocolorCommandArguments[] = {
  "color x",
  "color y",
  "transition time",
  "options mask",
  "options override",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclColorControlMovetocolortempCommandArguments[] = {
  "color temperature",
  "transition time",
  "options mask",
  "options override",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclColorControlMovetohueCommandArguments[] = {
  "hue",
  "direction",
  "transition time",
  "options mask",
  "options override",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclColorControlMovetohueandsatCommandArguments[] = {
  "hue",
  "saturation",
  "transition time",
  "options mask",
  "options override",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclColorControlMovetosatCommandArguments[] = {
  "saturation",
  "transition time",
  "options mask",
  "options override",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclColorControlStepcolorCommandArguments[] = {
  "step x",
  "step y",
  "transition time",
  "options mask",
  "options override",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclColorControlStepcolortempCommandArguments[] = {
  "step mode",
  "step size",
  "transition time",
  "color temperature minimum",
  "color temperature maximum",
  "options mask",
  "options override",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclColorControlStephueCommandArguments[] = {
  "step mode",
  "step size",
  "transition time",
  "options mask",
  "options override",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclColorControlStepsatCommandArguments[] = {
  "step mode",
  "step size",
  "transition time",
  "options mask",
  "options override",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclColorControlStopmovestepCommandArguments[] = {
  "options mask",
  "options override",
  NULL
};
#endif

static EmberCommandEntry emberCommandTableZclColorControlCommands[] = {
  emberCommandEntryActionWithDetails("emovehue", zclColorControlEmovehueCommand, "uv", "Command description for EnhancedMoveHue", emberCommandTableZclColorControlEmovehueCommandArguments),
  emberCommandEntryActionWithDetails("emovetohue", zclColorControlEmovetohueCommand, "vuv", "Command description for EnhancedMoveToHue", emberCommandTableZclColorControlEmovetohueCommandArguments),
  emberCommandEntryActionWithDetails("emovetohueandsat", zclColorControlEmovetohueandsatCommand, "vuv", "Command description for EnhancedMoveToHueAndSaturation", emberCommandTableZclColorControlEmovetohueandsatCommandArguments),
  emberCommandEntryActionWithDetails("estephue", zclColorControlEstephueCommand, "uvv", "Command description for EnhancedStepHue", emberCommandTableZclColorControlEstephueCommandArguments),
  emberCommandEntryActionWithDetails("loop", zclColorControlLoopCommand, "uuuvv", "Command description for ColorLoopSet", emberCommandTableZclColorControlLoopCommandArguments),
  emberCommandEntryActionWithDetails("movecolor", zclColorControlMovecolorCommand, "rruu", "Moves the color.", emberCommandTableZclColorControlMovecolorCommandArguments),
  emberCommandEntryActionWithDetails("movecolortemp", zclColorControlMovecolortempCommand, "uvvvuu", "Command description for MoveColorTemperature", emberCommandTableZclColorControlMovecolortempCommandArguments),
  emberCommandEntryActionWithDetails("movehue", zclColorControlMovehueCommand, "uuuu", "Move hue up or down at specified rate.", emberCommandTableZclColorControlMovehueCommandArguments),
  emberCommandEntryActionWithDetails("movesat", zclColorControlMovesatCommand, "uuuu", "Move saturation up or down at specified rate.", emberCommandTableZclColorControlMovesatCommandArguments),
  emberCommandEntryActionWithDetails("movetocolor", zclColorControlMovetocolorCommand, "vvvuu", "Move to specified color.", emberCommandTableZclColorControlMovetocolorCommandArguments),
  emberCommandEntryActionWithDetails("movetocolortemp", zclColorControlMovetocolortempCommand, "vvuu", "Move to a specific color temperature.", emberCommandTableZclColorControlMovetocolortempCommandArguments),
  emberCommandEntryActionWithDetails("movetohue", zclColorControlMovetohueCommand, "uuvuu", "Move to specified hue.", emberCommandTableZclColorControlMovetohueCommandArguments),
  emberCommandEntryActionWithDetails("movetohueandsat", zclColorControlMovetohueandsatCommand, "uuvuu", "Move to hue and saturation.", emberCommandTableZclColorControlMovetohueandsatCommandArguments),
  emberCommandEntryActionWithDetails("movetosat", zclColorControlMovetosatCommand, "uvuu", "Move to specified saturation.", emberCommandTableZclColorControlMovetosatCommandArguments),
  emberCommandEntryActionWithDetails("stepcolor", zclColorControlStepcolorCommand, "rrvuu", "Steps the lighting to a specific color.", emberCommandTableZclColorControlStepcolorCommandArguments),
  emberCommandEntryActionWithDetails("stepcolortemp", zclColorControlStepcolortempCommand, "uvvvvuu", "Command description for StepColorTemperature", emberCommandTableZclColorControlStepcolortempCommandArguments),
  emberCommandEntryActionWithDetails("stephue", zclColorControlStephueCommand, "uuuuu", "Step hue up or down by specified size at specified rate.", emberCommandTableZclColorControlStephueCommandArguments),
  emberCommandEntryActionWithDetails("stepsat", zclColorControlStepsatCommand, "uuuuu", "Step saturation up or down by specified size at specified rate.", emberCommandTableZclColorControlStepsatCommandArguments),
  emberCommandEntryActionWithDetails("stopmovestep", zclColorControlStopmovestepCommand, "uu", "Command description for StopMoveStep", emberCommandTableZclColorControlStopmovestepCommandArguments),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclBasicGlsCommandArguments[] = {
  "start locale",
  "max locales requested",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclBasicGlsrCommandArguments[] = {
  "discovery complete",
  "locale supported",
  "",
  NULL
};
#endif

static EmberCommandEntry emberCommandTableZclBasicCommands[] = {
  emberCommandEntryActionWithDetails("gls", zclBasicGlsCommand, "bu", "This command gets locales supported.", emberCommandTableZclBasicGlsCommandArguments),
  emberCommandEntryActionWithDetails("glsr", zclBasicGlsrCommand, "ub*", "The locales supported response command is sent in response to a get lo ...", emberCommandTableZclBasicGlsrCommandArguments),
  emberCommandEntryActionWithDetails("rtfd", zclBasicRtfdCommand, "", "Command that resets all attribute values to factory default.", NULL),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclBarrierControlGoToPercentCommandArguments[] = {
  "percent open",
  NULL
};
#endif

static EmberCommandEntry emberCommandTableZclBarrierControlCommands[] = {
  emberCommandEntryActionWithDetails("go-to-percent", zclBarrierControlGoToPercentCommand, "u", "Command to instruct a barrier to go to a percent open state.", emberCommandTableZclBarrierControlGoToPercentCommandArguments),
  emberCommandEntryActionWithDetails("stop", zclBarrierControlStopCommand, "", "Command that instructs the barrier to stop moving.", NULL),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclMfgCodeCommandArguments[] = {
  "Manufacturer Specific Id",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclTimeCommandArguments[] = {
  "ZigBee UTC time, number of seconds since the year 2000",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclUseNextSequenceCommandArguments[] = {
  "bool value indicating whether raw command will use the incremented seq ...",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableZclXDefaultRespCommandArguments[] = {
  "bool value indicating whether the disable default response bit is set( ...",
  NULL
};
#endif

static EmberCommandEntry emberCommandTableZclCommands[] = {
  emberCommandEntrySubMenu("barrier-control", emberCommandTableZclBarrierControlCommands, ""),
  emberCommandEntrySubMenu("basic", emberCommandTableZclBasicCommands, ""),
  emberCommandEntrySubMenu("color-control", emberCommandTableZclColorControlCommands, ""),
  emberCommandEntrySubMenu("global", emberCommandTableZclGlobalCommands, ""),
  emberCommandEntrySubMenu("groups", emberCommandTableZclGroupsCommands, ""),
  emberCommandEntrySubMenu("identify", emberCommandTableZclIdentifyCommands, ""),
  emberCommandEntrySubMenu("level-control", emberCommandTableZclLevelControlCommands, ""),
  emberCommandEntrySubMenu("lock", emberCommandTableZclLockCommands, ""),
  emberCommandEntrySubMenu("metering", emberCommandTableZclMeteringCommands, ""),
  emberCommandEntryActionWithDetails("mfg-code", zclMfgCodeCommand, "v", "Sets the two byte manufacturer specific identifier to use for the next ...", emberCommandTableZclMfgCodeCommandArguments),
  emberCommandEntrySubMenu("mfglib", emberCommandTableZclMfglibCommands, ""),
  emberCommandEntrySubMenu("on-off", emberCommandTableZclOnOffCommands, ""),
  emberCommandEntrySubMenu("ota-config", emberCommandTableZclOtaConfigCommands, ""),
  emberCommandEntrySubMenu("poll-control", emberCommandTableZclPollControlCommands, ""),
  emberCommandEntrySubMenu("scenes", emberCommandTableZclScenesCommands, ""),
  emberCommandEntrySubMenu("test", emberCommandTableZclTestCommands, ""),
  emberCommandEntryActionWithDetails("time", zclTimeCommand, "w", "Cli command to call emberAfSetTime function documented in af.h", emberCommandTableZclTimeCommandArguments),
  emberCommandEntrySubMenu("tstat", emberCommandTableZclTstatCommands, ""),
  emberCommandEntryActionWithDetails("use-next-sequence", zclUseNextSequenceCommand, "u", "Sets the flag to use the incremented sequence number from the framewor ...", emberCommandTableZclUseNextSequenceCommandArguments),
  emberCommandEntrySubMenu("window-covering", emberCommandTableZclWindowCoveringCommands, ""),
  emberCommandEntryActionWithDetails("x-default-resp", zclXDefaultRespCommand, "u", "Sets the Disable Default Response Frame Control bit to use for the nex ...", emberCommandTableZclXDefaultRespCommandArguments),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD) && !defined(EMBER_AF_HAS_SECURITY_PROFILE_NONE)
static const char * const emberCommandTableSecurityMfgTokenSetCommandArguments[] = {
  "magic number",
  "value",
  NULL
};
#endif

static EmberCommandEntry emberCommandTableSecurityMfgTokenCommands[] = {
#if !defined(EMBER_AF_HAS_SECURITY_PROFILE_NONE)
  emberCommandEntryActionWithDetails("get", getSetMfgToken, "", "", NULL),
#endif
#if !defined(EMBER_AF_HAS_SECURITY_PROFILE_NONE)
  emberCommandEntryActionWithDetails("set", getSetMfgToken, "wv", "", emberCommandTableSecurityMfgTokenSetCommandArguments),
#endif
  emberCommandEntryTerminator()
};

static EmberCommandEntry emberCommandTableSecurityCommands[] = {
  emberCommandEntrySubMenu("mfg-token", emberCommandTableSecurityMfgTokenCommands, ""),
  emberCommandEntryTerminator()
};

static EmberCommandEntry emberCommandTablePrintEntropyCommands[] = {
  emberCommandEntryActionWithDetails("source", emberAfPrintEntropySource, "", "Print the the entropy source that is used for true random number gener ...", NULL),
  emberCommandEntryTerminator()
};

static EmberCommandEntry emberCommandTablePrintCommands[] = {
  emberCommandEntryActionWithDetails("attr", emberAfPrintAttributeTable, "", "Print the attribute table.", NULL),
  emberCommandEntrySubMenu("entropy", emberCommandTablePrintEntropyCommands, ""),
  emberCommandEntryActionWithDetails("time", printTimeCommand, "", "Print out the time information", NULL),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD) && defined(EMBER_AF_PLUGIN_TRUST_CENTER_BACKUP_POSIX_FILE_BACKUP_SUPPORT)
static const char * const emberCommandTablePluginTrustCenterBackupFileExportCommandArguments[] = {
  "path",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD) && defined(EMBER_AF_PLUGIN_TRUST_CENTER_BACKUP_POSIX_FILE_BACKUP_SUPPORT)
static const char * const emberCommandTablePluginTrustCenterBackupFileImportCommandArguments[] = {
  "path",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginTrustCenterBackupImportKeyCommandArguments[] = {
  "index",
  "partner e u i64",
  "new key",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginTrustCenterBackupSetExtPanCommandArguments[] = {
  "extended pan id",
  NULL
};
#endif

static EmberCommandEntry emberCommandTablePluginTrustCenterBackupCommands[] = {
  emberCommandEntryActionWithDetails("clear-import", importClearCommand, "", "Clear the import data set.", NULL),
#if defined(EMBER_AF_PLUGIN_TRUST_CENTER_BACKUP_POSIX_FILE_BACKUP_SUPPORT)
  emberCommandEntryActionWithDetails("file-export", emAfTcExportCommand, "b", "Write the TC backup data to a file.", emberCommandTablePluginTrustCenterBackupFileExportCommandArguments),
#endif
#if defined(EMBER_AF_PLUGIN_TRUST_CENTER_BACKUP_POSIX_FILE_BACKUP_SUPPORT)
  emberCommandEntryActionWithDetails("file-import", emAfTcImportCommand, "b", "Read the TC Backup data from a file and bring the TC back online.", emberCommandTablePluginTrustCenterBackupFileImportCommandArguments),
#endif
  emberCommandEntryActionWithDetails("import-key", importKeyCommand, "ubb", "Set a key in the import data set.", emberCommandTablePluginTrustCenterBackupImportKeyCommandArguments),
  emberCommandEntryActionWithDetails("print-export", printExportDataCommand, "", "Print the set of export data that a TC must backup.", NULL),
  emberCommandEntryActionWithDetails("print-import", printImportDataCommand, "", "Print the import data set.", NULL),
  emberCommandEntryActionWithDetails("restore", restoreFromBackupCommand, "", "Use the import data set in a restore operation to bring the TC back on ...", NULL),
  emberCommandEntryActionWithDetails("set-ext-pan", setExtendedPanIdCommand, "b", "Set the extended PAN ID in the import data set.", emberCommandTablePluginTrustCenterBackupSetExtPanCommandArguments),
  emberCommandEntryTerminator()
};

static EmberCommandEntry emberCommandTablePluginTestHarnessTcKeepaliveCommands[] = {
  emberCommandEntryActionWithDetails("send", emberAfPluginTestHarnessTcKeepaliveSendCommand, "", "Sends a Trust Center Keepalive.", NULL),
  emberCommandEntryActionWithDetails("start", emberAfPluginTestHarnessTcKeepaliveStartStopCommand, "", "Starts the TC keepalive state machine.", NULL),
  emberCommandEntryActionWithDetails("stop", emberAfPluginTestHarnessTcKeepaliveStartStopCommand, "", "Stops the TC keepalive state machine.", NULL),
  emberCommandEntryTerminator()
};

static EmberCommandEntry emberCommandTablePluginTestHarnessStackLimitBeaconsCommands[] = {
  emberCommandEntryActionWithDetails("off", emberAfPluginTestHarnessLimitBeaconsOnOffCommand, "", "Disables a limit to the max number of outgoing beacons.", NULL),
  emberCommandEntryActionWithDetails("on", emberAfPluginTestHarnessLimitBeaconsOnOffCommand, "", "Enables a limit to the max number of outgoing beacons.", NULL),
  emberCommandEntryTerminator()
};

static EmberCommandEntry emberCommandTablePluginTestHarnessStackCommands[] = {
  emberCommandEntrySubMenu("limit-beacons", emberCommandTablePluginTestHarnessStackLimitBeaconsCommands, ""),
  emberCommandEntryTerminator()
};

static EmberCommandEntry emberCommandTablePluginTestHarnessRegistrationCommands[] = {
  emberCommandEntryActionWithDetails("off", emberAfPluginTestHarnessSetRegistrationCommand, "", "Turns off automatic SE registration.", NULL),
  emberCommandEntryActionWithDetails("on", emberAfPluginTestHarnessSetRegistrationCommand, "", "Turns on automatic SE registration.", NULL),
  emberCommandEntryTerminator()
};

static EmberCommandEntry emberCommandTablePluginTestHarnessRadioCommands[] = {
  emberCommandEntryActionWithDetails("off", emberAfPluginTestHarnessRadioOnOffCommand, "", "Turns off the radio so that no messages are sent.", NULL),
  emberCommandEntryActionWithDetails("on", emberAfPluginTestHarnessRadioOnOffCommand, "", "Turns on the radio if it was previously turned off", NULL),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginTestHarnessPriceSendNewFieldsCommandArguments[] = {
  "Boolean indicating whether to send new fields.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginTestHarnessPriceSendSe10FieldsCommandArguments[] = {
  "Boolean indicating whether to send new fields.",
  NULL
};
#endif

static EmberCommandEntry emberCommandTablePluginTestHarnessPriceCommands[] = {
  emberCommandEntryActionWithDetails("send-new-fields", emberAfPluginTestHarnessPriceSendNewFieldsCommand, "u", "Controls whether the new SE 1.1 price fields are included.", emberCommandTablePluginTestHarnessPriceSendNewFieldsCommandArguments),
  emberCommandEntryActionWithDetails("send-se10-fields", emberAfPluginTestHarnessPriceSendNewFieldsCommand, "u", "Controls whether the new SE 1.1 price fields are included.", emberCommandTablePluginTestHarnessPriceSendSe10FieldsCommandArguments),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginTestHarnessOtaImageMangleCommandArguments[] = {
  "The byte index into the OTA image that will be mangled.",
  NULL
};
#endif

static EmberCommandEntry emberCommandTablePluginTestHarnessOtaCommands[] = {
  emberCommandEntryActionWithDetails("image-mangle", emberAfPluginTestHarnessOtaImageMangleCommand, "v", "Mangles the Simple Storage RAM OTA image.", emberCommandTablePluginTestHarnessOtaImageMangleCommandArguments),
  emberCommandEntryTerminator()
};

static EmberCommandEntry emberCommandTablePluginTestHarnessKeyUpdateCommands[] = {
  emberCommandEntryActionWithDetails("broadcast", emberAfPluginTestHarnessKeyUpdateCommand, "", "Changes TC NWK key update mechanism to broadcast.", NULL),
  emberCommandEntryActionWithDetails("now", emberAfPluginTestHarnessKeyUpdateCommand, "", "Starts a TC NWK key update now", NULL),
  emberCommandEntryActionWithDetails("unicast", emberAfPluginTestHarnessKeyUpdateCommand, "", "Changes TC NWK key update mechanism to unicast with APS security.", NULL),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginTestHarnessKeyEstablishmentCertMangleChangeByteCommandArguments[] = {
  "The index of the certificate byte to change",
  "The new value of the certificate byte",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginTestHarnessKeyEstablishmentCertMangleCorruptCommandArguments[] = {
  "The index of the certificate byte to corrupt",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginTestHarnessKeyEstablishmentCertMangleIssuerCommandArguments[] = {
  "The EUI64 of the issuer (big endian).",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginTestHarnessKeyEstablishmentCertMangleLengthCommandArguments[] = {
  "The positive or negative change in length.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginTestHarnessKeyEstablishmentCertMangleSubjectCommandArguments[] = {
  "The EUI64 of the subject (big endian).",
  NULL
};
#endif

static EmberCommandEntry emberCommandTablePluginTestHarnessKeyEstablishmentCertMangleCommands[] = {
  emberCommandEntryActionWithDetails("change-byte", emberAfPluginTestHarnessCertMangleCommand, "uu", "Changes a single byte in the cert", emberCommandTablePluginTestHarnessKeyEstablishmentCertMangleChangeByteCommandArguments),
  emberCommandEntryActionWithDetails("corrupt", emberAfPluginTestHarnessCertMangleCommand, "u", "Corrupts a single byte in the cert", emberCommandTablePluginTestHarnessKeyEstablishmentCertMangleCorruptCommandArguments),
  emberCommandEntryActionWithDetails("issuer", emberAfPluginTestHarnessCertMangleCommand, "b", "Changes the issuer in the certificate.", emberCommandTablePluginTestHarnessKeyEstablishmentCertMangleIssuerCommandArguments),
  emberCommandEntryActionWithDetails("length", emberAfPluginTestHarnessCertMangleCommand, "s", "Mangles the length of the certificate", emberCommandTablePluginTestHarnessKeyEstablishmentCertMangleLengthCommandArguments),
  emberCommandEntryActionWithDetails("subject", emberAfPluginTestHarnessCertMangleCommand, "b", "Changes the subject (EUI64) of the cert", emberCommandTablePluginTestHarnessKeyEstablishmentCertMangleSubjectCommandArguments),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginTestHarnessKeyEstablishmentDelayCbkeCommandArguments[] = {
  "Set the actual delay that occurs.",
  "Sets the advertised delay sent to the partner of key establishment",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginTestHarnessKeyEstablishmentKeyMangleCommandArguments[] = {
  "The positive or negative change in length.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginTestHarnessKeyEstablishmentNewKeyPolicyCommandArguments[] = {
  "Allows / disallows new key establishment requests.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginTestHarnessKeyEstablishmentOutOfSequenceCommandArguments[] = {
  "The out-of-sequence command ID to send.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginTestHarnessKeyEstablishmentSetAvailableSuiteCommandArguments[] = {
  "This field holds the type        of key establishment suit ...",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginTestHarnessKeyEstablishmentSuiteCommandArguments[] = {
  "This field holds the type        of key establishment suit ...",
  NULL
};
#endif

static EmberCommandEntry emberCommandTablePluginTestHarnessKeyEstablishmentCommands[] = {
  emberCommandEntryActionWithDetails("adv-aps-fc", emberAfPluginTestHarnessKeyEstablishmentSetModeCommand, "", "Advances the local device's outgoing APS FC by 4096.", NULL),
  emberCommandEntrySubMenu("cert-mangle", emberCommandTablePluginTestHarnessKeyEstablishmentCertMangleCommands, ""),
  emberCommandEntryActionWithDetails("default-resp", emberAfPluginTestHarnessKeyEstablishmentSetModeCommand, "", "Sends a default response error message in response to initate KE.", NULL),
  emberCommandEntryActionWithDetails("delay-cbke", emberAfPluginTestHarnessKeyEstablishmentSetModeCommand, "vv", "Changes the advertised delays by the local device for CBKE.", emberCommandTablePluginTestHarnessKeyEstablishmentDelayCbkeCommandArguments),
  emberCommandEntryActionWithDetails("key-mangle", emberAfPluginTestHarnessKeyEstablishmentKeyMangleCommand, "s", "Mangles the length of the empheral key.", emberCommandTablePluginTestHarnessKeyEstablishmentKeyMangleCommandArguments),
  emberCommandEntryActionWithDetails("new-key-policy", emberAfPluginTestHarnessKeyEstablishmentSetModeCommand, "u", "Sets the policy of whether the TC allows new KE requests.", emberCommandTablePluginTestHarnessKeyEstablishmentNewKeyPolicyCommandArguments),
  emberCommandEntryActionWithDetails("no-resources", emberAfPluginTestHarnessKeyEstablishmentSetModeCommand, "", "All received KE requests will be responded with 'no resources'.", NULL),
  emberCommandEntryActionWithDetails("normal-mode", emberAfPluginTestHarnessKeyEstablishmentSetModeCommand, "", "Sets the key establishment mode to normal.", NULL),
  emberCommandEntryActionWithDetails("out-of-sequence", emberAfPluginTestHarnessKeyEstablishmentSetModeCommand, "u", "All received KE requests will be responded with 'no resources'.", emberCommandTablePluginTestHarnessKeyEstablishmentOutOfSequenceCommandArguments),
  emberCommandEntryActionWithDetails("reset-aps-fc", emberAfPluginTestHarnessKeyEstablishmentSetModeCommand, "", "Forces the local device to reset its outgoing APS FC.", NULL),
  emberCommandEntryActionWithDetails("set-available-suite", emberAfPluginTestHarnessKeyEstablishmentSetAvailableSuiteCommand , "v", "Selects between the CBKE 163k1 and 283k1 suites.", emberCommandTablePluginTestHarnessKeyEstablishmentSetAvailableSuiteCommandArguments),
  emberCommandEntryActionWithDetails("suite", emberAfPluginTestHarnessKeyEstablishmentSelectSuiteCommand, "v", "Selects between the CBKE 163k1 and 283k1 suites.", emberCommandTablePluginTestHarnessKeyEstablishmentSuiteCommandArguments),
  emberCommandEntryActionWithDetails("timeout", emberAfPluginTestHarnessKeyEstablishmentSetModeCommand, "", "Artificially creates a timeout by delaying an outgoing message.", NULL),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginTestHarnessEndpointClusterEndpointIndexCommandArguments[] = {
  "The local endpoint of the cluster.",
  "The cluster whose index is needed.",
  "0 for client-side attributes or 1 for server-side attributes.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginTestHarnessEndpointDisableCommandArguments[] = {
  "The endpoint number.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginTestHarnessEndpointEnableCommandArguments[] = {
  "The endpoint number.",
  NULL
};
#endif

static EmberCommandEntry emberCommandTablePluginTestHarnessEndpointCommands[] = {
  emberCommandEntryActionWithDetails("cluster-endpoint-index", emberAfPluginTestHarnessClusterEndpointIndexCommand, "uvu", "Get cluster endpoint index", emberCommandTablePluginTestHarnessEndpointClusterEndpointIndexCommandArguments),
  emberCommandEntryActionWithDetails("disable", emberAfPluginTestHarnessEnableDisableEndpointCommand, "u", "Disables the endpont to receive messages and be discovered", emberCommandTablePluginTestHarnessEndpointDisableCommandArguments),
  emberCommandEntryActionWithDetails("enable", emberAfPluginTestHarnessEnableDisableEndpointCommand, "u", "Enables the endpont to receive messages and be discovered", emberCommandTablePluginTestHarnessEndpointEnableCommandArguments),
  emberCommandEntryActionWithDetails("status", emberAfPluginTestHarnessEndpointStatusCommand, "", "Disables the endpont to receive messages and be discovered", NULL),
  emberCommandEntryTerminator()
};

static EmberCommandEntry emberCommandTablePluginTestHarnessConcentratorCommands[] = {
  emberCommandEntryActionWithDetails("start", emberAfPluginTestHarnessConcentratorStartStopCommand, "", "Starts the concentrator's periodic broadcasts.", NULL),
  emberCommandEntryActionWithDetails("stop", emberAfPluginTestHarnessConcentratorStartStopCommand, "", "Starts the concentrator's periodic broadcasts.", NULL),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD) && defined(EMBER_AF_PLUGIN_NETWORK_FIND)
static const char * const emberCommandTablePluginTestHarnessChannelMaskAddCommandArguments[] = {
  "The 802.15.4 chanel to add.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD) && defined(EMBER_AF_PLUGIN_NETWORK_FIND)
static const char * const emberCommandTablePluginTestHarnessChannelMaskRemoveCommandArguments[] = {
  "The 802.15.4 chanel to remove.",
  NULL
};
#endif

static EmberCommandEntry emberCommandTablePluginTestHarnessChannelMaskCommands[] = {
#if defined(EMBER_AF_PLUGIN_NETWORK_FIND)
  emberCommandEntryActionWithDetails("add", emberAfPluginTestHarnessChannelMaskAddOrRemoveCommand, "u", "Add a channel to the mask", emberCommandTablePluginTestHarnessChannelMaskAddCommandArguments),
#endif
#if defined(EMBER_AF_PLUGIN_NETWORK_FIND)
  emberCommandEntryActionWithDetails("all", emberAfPluginTestHarnessChannelMaskResetClearAllCommand, "", "Sets the channel mask to all channels", NULL),
#endif
#if defined(EMBER_AF_PLUGIN_NETWORK_FIND)
  emberCommandEntryActionWithDetails("clear", emberAfPluginTestHarnessChannelMaskResetClearAllCommand, "", "Clears the channel mask used by network find.", NULL),
#endif
#if defined(EMBER_AF_PLUGIN_NETWORK_FIND)
  emberCommandEntryActionWithDetails("remove", emberAfPluginTestHarnessChannelMaskAddOrRemoveCommand, "u", "Remove a channel from the mask", emberCommandTablePluginTestHarnessChannelMaskRemoveCommandArguments),
#endif
#if defined(EMBER_AF_PLUGIN_NETWORK_FIND)
  emberCommandEntryActionWithDetails("reset", emberAfPluginTestHarnessChannelMaskResetClearAllCommand, "", "Resets the channel mask back to the app default.", NULL),
#endif
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginTestHarnessAttrOptionsCommandArguments[] = {
  "type",
  "timeout",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginTestHarnessAttrSetDestCommandArguments[] = {
  "addr",
  "endpoint",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginTestHarnessAttrStartTestCommandArguments[] = {
  "cluster id",
  "attr start id",
  "attr end id",
  "client to server",
  NULL
};
#endif

static EmberCommandEntry emberCommandTablePluginTestHarnessAttrCommands[] = {
  emberCommandEntryActionWithDetails("options", setOptionsCommand, "uv", "Set the options for the attributes tests.", emberCommandTablePluginTestHarnessAttrOptionsCommandArguments),
  emberCommandEntryActionWithDetails("set-dest", setDestinationCommand, "vu", "Set the destination for the attributes tests.", emberCommandTablePluginTestHarnessAttrSetDestCommandArguments),
  emberCommandEntryActionWithDetails("start-test", startTestCommand, "vvvu", "Start the attributes test.", emberCommandTablePluginTestHarnessAttrStartTestCommandArguments),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginTestHarnessApsSecForClusterOnCommandArguments[] = {
  "The cluster ID to add APS security to automatically.",
  NULL
};
#endif

static EmberCommandEntry emberCommandTablePluginTestHarnessApsSecForClusterCommands[] = {
  emberCommandEntryActionWithDetails("off", emberAfPluginTestHarnessSetApsSecurityForClusterCommand, "", "Turns off automatic APS security for the previously specified cluster.", NULL),
  emberCommandEntryActionWithDetails("on", emberAfPluginTestHarnessSetApsSecurityForClusterCommand, "v", "Turns on automatic APS security for the specified cluster.", emberCommandTablePluginTestHarnessApsSecForClusterOnCommandArguments),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginTestHarnessAddChildCommandArguments[] = {
  "The shortId of the child device.",
  "The EUI64 of the child (big endian).",
  "The node type of the child device.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginTestHarnessSetComplianceRevisionCommandArguments[] = {
  "The compliance version",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginTestHarnessSetRadioPowerCommandArguments[] = {
  "The radio power to set.",
  NULL
};
#endif

static EmberCommandEntry emberCommandTablePluginTestHarnessCommands[] = {
  emberCommandEntryActionWithDetails("add-child", emberAfPluginTestHarnessAddChildCommand, "vbu", "Adds a child to the child table.", emberCommandTablePluginTestHarnessAddChildCommandArguments),
  emberCommandEntrySubMenu("aps-sec-for-cluster", emberCommandTablePluginTestHarnessApsSecForClusterCommands, ""),
  emberCommandEntrySubMenu("attr", emberCommandTablePluginTestHarnessAttrCommands, ""),
  emberCommandEntrySubMenu("channel-mask", emberCommandTablePluginTestHarnessChannelMaskCommands, ""),
  emberCommandEntrySubMenu("concentrator", emberCommandTablePluginTestHarnessConcentratorCommands, ""),
  emberCommandEntrySubMenu("endpoint", emberCommandTablePluginTestHarnessEndpointCommands, ""),
  emberCommandEntryActionWithDetails("hash-the-flash", emAfTestHarnessStartImageStampCalculation, "", "Runs the AES-CCM algorithm over the contents of the software image to  ...", NULL),
  emberCommandEntrySubMenu("key-establishment", emberCommandTablePluginTestHarnessKeyEstablishmentCommands, ""),
  emberCommandEntrySubMenu("key-update", emberCommandTablePluginTestHarnessKeyUpdateCommands, ""),
  emberCommandEntrySubMenu("ota", emberCommandTablePluginTestHarnessOtaCommands, ""),
  emberCommandEntrySubMenu("price", emberCommandTablePluginTestHarnessPriceCommands, ""),
  emberCommandEntrySubMenu("radio", emberCommandTablePluginTestHarnessRadioCommands, ""),
  emberCommandEntrySubMenu("registration", emberCommandTablePluginTestHarnessRegistrationCommands, ""),
  emberCommandEntryActionWithDetails("set-compliance-revision", emberAfPluginTestHarnessSetNodeDescriptorComplianceRevision, "u", "Setting a compliance revision for a device such that the device can ac ...", emberCommandTablePluginTestHarnessSetComplianceRevisionCommandArguments),
  emberCommandEntryActionWithDetails("set-radio-power", emberAfPluginTestHarnessSetRadioPower, "u", "Sets the radio power.", emberCommandTablePluginTestHarnessSetRadioPowerCommandArguments),
  emberCommandEntrySubMenu("stack", emberCommandTablePluginTestHarnessStackCommands, ""),
  emberCommandEntryActionWithDetails("status", emberAfPluginTestHarnessStatusCommand, "", "Display the current status of the test harness.", NULL),
  emberCommandEntrySubMenu("tc-keepalive", emberCommandTablePluginTestHarnessTcKeepaliveCommands, ""),
  emberCommandEntryTerminator()
};

static EmberCommandEntry emberCommandTablePluginStackDiagnosticsCommands[] = {
  emberCommandEntryActionWithDetails("child-table", printChildTable, "", "Prints out the entries in the stack's child table.", NULL),
  emberCommandEntryActionWithDetails("info", printInfo, "", "Prints out general information about the state of the stack.", NULL),
  emberCommandEntryActionWithDetails("neighbor-table", printNeighborTable, "", "Prints out the entries in the stack's neighbor table.", NULL),
  emberCommandEntryActionWithDetails("route-table", printRouteTable, "", "Prints out the entries in the stack's route table.", NULL),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginSimpleMeteringClientGetSampledDataCommandArguments[] = {
  "The network address of the server to which the request will be sent.",
  "The local endpoint from which the request will be sent.",
  "The remote endpoint to which the request will be sent.",
  "The sample id as received in a previous startSamplingResponse",
  "The earliest start time sampling",
  "An 8 bit enumeration that identifies the required type of sampled data",
  "The total number of samples.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginSimpleMeteringClientLocalChangeSupplyCommandArguments[] = {
  "The network address of the server to which the request will be sent.",
  "The local endpoint from which the request will be sent.",
  "The remote endpoint to which the request will be sent.",
  "The proposed supply status: either ON(2) or OFF/ARMED(1)",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginSimpleMeteringClientSchSnapshotCommandArguments[] = {
  "The network address of the server to which the request will be sent.",
  "The local endpoint from which the request will be sent.",
  "The remote endpoint to which the request will be sent.",
  "The issuerId.",
  "The commandIndex.",
  "The total number of commands",
  "The snapshot schedule Id.",
  "The start time.",
  "The snapshot schedule. 3 bytes",
  "The snapshot Type.",
  "The snapshot schedule cause.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginSimpleMeteringClientStartSamplingCommandArguments[] = {
  "The network address of the server to which the request will be sent.",
  "The local endpoint from which the request will be sent.",
  "The remote endpoint to which the request will be sent.",
  "The issuerId.",
  "The time to start sampling",
  "An 8 bit enumeration that identifies the type of data being sampled",
  "An unsigned 16-bit field representing the interval or time in seconds  ...",
  "A 16 bit unsigned integer that represents the number of samples to be  ...",
  NULL
};
#endif

static EmberCommandEntry emberCommandTablePluginSimpleMeteringClientCommands[] = {
  emberCommandEntryActionWithDetails("get-sampled-data", emAfPluginSimpleMeteringClientCliGetSampledData, "vuuvwuv", "Send a start sampling command to a metering server.", emberCommandTablePluginSimpleMeteringClientGetSampledDataCommandArguments),
  emberCommandEntryActionWithDetails("local-change-supply", emAfPluginSimpleMeteringClientCliLocalChangeSupply, "vuuu", "Send a start sampling command to a metering server.", emberCommandTablePluginSimpleMeteringClientLocalChangeSupplyCommandArguments),
  emberCommandEntryActionWithDetails("sch-snapshot", emAfPluginSimpleMeteringClientCliSchSnapshot, "vuuwuuuwwuw", "Schedule a snapshot.", emberCommandTablePluginSimpleMeteringClientSchSnapshotCommandArguments),
  emberCommandEntryActionWithDetails("start-sampling", emAfPluginSimpleMeteringClientCliStartSampling, "vuuwwuvv", "Send a start sampling command to a metering server.", emberCommandTablePluginSimpleMeteringClientStartSamplingCommandArguments),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginReportingAddCommandArguments[] = {
  "The local endpoint from which the attribute is reported.",
  "The cluster where the attribute is located.",
  "The id of the attribute being reported.",
  "0 for client-side attributes or 1 for server-side attributes.",
  "The minimum reporting interval, measured in seconds.",
  "The maximum reporting interval, measured in seconds.",
  "The minimum change to the attribute that will result in a report being ...",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginReportingRemoveCommandArguments[] = {
  "The index of the report to be removed.",
  NULL
};
#endif

static EmberCommandEntry emberCommandTablePluginReportingCommands[] = {
  emberCommandEntryActionWithDetails("add", emAfPluginReportingCliAdd, "uvvuvvw", "Add a new entry to the report table.", emberCommandTablePluginReportingAddCommandArguments),
  emberCommandEntryActionWithDetails("clear", emAfPluginReportingCliClear, "", "Clear all entries from the report table.", NULL),
  emberCommandEntryActionWithDetails("clear-last-report-time", emAfPluginReportingCliClearLastReportTime, "", "Clear last report time of attributes.", NULL),
  emberCommandEntryActionWithDetails("print", emAfPluginReportingCliPrint, "", "Print the report table.", NULL),
  emberCommandEntryActionWithDetails("remove", emAfPluginReportingCliRemove, "u", "Remove an entry from the report table.", emberCommandTablePluginReportingRemoveCommandArguments),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginPollControlClientModeCommandArguments[] = {
  "The fast polling mode.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginPollControlClientRespondCommandArguments[] = {
  "The response mode.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginPollControlClientTimeoutCommandArguments[] = {
  "The fast polling timeout.",
  NULL
};
#endif

static EmberCommandEntry emberCommandTablePluginPollControlClientCommands[] = {
  emberCommandEntryActionWithDetails("mode", mode, "u", "Set the fast polling mode.", emberCommandTablePluginPollControlClientModeCommandArguments),
  emberCommandEntryActionWithDetails("print", print, "", "Print the fast polling mode and timeout.", NULL),
  emberCommandEntryActionWithDetails("respond", respond, "u", "Set the response mode.", emberCommandTablePluginPollControlClientRespondCommandArguments),
  emberCommandEntryActionWithDetails("timeout", timeout, "v", "Set the fast polling timeout.", emberCommandTablePluginPollControlClientTimeoutCommandArguments),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginOtaStorageCommonDataPrintCommandArguments[] = {
  "The index of the image to print its data.",
  "The offset into the OTA image that will be printed.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginOtaStorageCommonDeleteCommandArguments[] = {
  "The index at which to begin bootloading the image",
  NULL
};
#endif

static EmberCommandEntry emberCommandTablePluginOtaStorageCommonCommands[] = {
  emberCommandEntryActionWithDetails("data-print", emAfOtaStorageDataPrint, "uw", "Print arbitray bytes of the OTA image on disk.", emberCommandTablePluginOtaStorageCommonDataPrintCommandArguments),
  emberCommandEntryActionWithDetails("delete", emAfOtaImageDelete, "u", "Deletes the image at the specified index.", emberCommandTablePluginOtaStorageCommonDeleteCommandArguments),
  emberCommandEntryActionWithDetails("printImages", emAfOtaPrintAllImages, "", "Prints the images.", NULL),
  emberCommandEntryActionWithDetails("reload", emAfOtaReloadStorageDevice, "", "Reload the storage device.", NULL),
  emberCommandEntryActionWithDetails("storage-info", emAfOtaStorageInfoPrint, "", "Print information about the storage device.", NULL),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginOtaServerPolicyBlockRequestCommandArguments[] = {
  "0: Send block (default), 1: Delay download once for 2 minutes, 2: Alwa ...",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD) && defined(EMBER_TEST)
static const char * const emberCommandTablePluginOtaServerPolicyClientDelayUnitsCommandArguments[] = {
  "The unit to treat the minimum block period field.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginOtaServerPolicyImageReqMinPeriodCommandArguments[] = {
  "The minimum block period in milliseconds.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginOtaServerPolicyPageReqMissCommandArguments[] = {
  "0: Upgrade if server has newer (default), 1: Downgrade if server has o ...",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginOtaServerPolicyPageReqSupCommandArguments[] = {
  "0: Upgrade if server has newer (default), 1: Downgrade if server has o ...",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginOtaServerPolicyQueryCommandArguments[] = {
  "0: Upgrade if server has newer (default), 1: Downgrade if server has o ...",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginOtaServerPolicyUpgradeCommandArguments[] = {
  "0: Upgrade Now (default), 1: Upgrade in 2       minutes, 2: Ask me lat ...",
  NULL
};
#endif

static EmberCommandEntry emberCommandTablePluginOtaServerPolicyCommands[] = {
  emberCommandEntryActionWithDetails("blockRequest", setPolicy, "u", "Sets the policy used by the ota-server Policy Plugin when it receives  ...", emberCommandTablePluginOtaServerPolicyBlockRequestCommandArguments),
#if defined(EMBER_TEST)
  emberCommandEntryActionWithDetails("client-delay-units", otaServerSetClientDelayUnits, "u", "For testing, force the server to treat the Minimum Block Period in a c ...", emberCommandTablePluginOtaServerPolicyClientDelayUnitsCommandArguments),
#endif
  emberCommandEntryActionWithDetails("image-req-min-period", setPolicy, "v", "", emberCommandTablePluginOtaServerPolicyImageReqMinPeriodCommandArguments),
  emberCommandEntryActionWithDetails("page-req-miss", setPolicy, "u", "", emberCommandTablePluginOtaServerPolicyPageReqMissCommandArguments),
  emberCommandEntryActionWithDetails("page-req-sup", setPolicy, "u", "", emberCommandTablePluginOtaServerPolicyPageReqSupCommandArguments),
  emberCommandEntryActionWithDetails("print", emAfOtaServerPolicyPrint, "", "Prints the polices used by the OTA Server Policy Plugin", NULL),
  emberCommandEntryActionWithDetails("query", setPolicy, "u", "Sets the policy used by the OTA Server Policy Plugin when it receives  ...", emberCommandTablePluginOtaServerPolicyQueryCommandArguments),
  emberCommandEntryActionWithDetails("upgrade", setPolicy, "u", "Sets the policy used by the OTA Server Policy Plugin when it receives  ...", emberCommandTablePluginOtaServerPolicyUpgradeCommandArguments),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD) && defined(EMBER_TEST)
static const char * const emberCommandTablePluginOtaServerLoadFileCommandArguments[] = {
  "The file name.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginOtaServerNotifyCommandArguments[] = {
  "The node ID (can be a broadcast address) to which this OTA Notify mess ...",
  "Target endpoint for the OTA Notify message (only really meaningful for ...",
  "Used to specify which parameters you want included in the OTA Notify c ...",
  "Corresponds to QueryJitter parameter in the OTA Upgrade cluster specif ...",
  "Manufacturer ID for the image being advertised (should match the mfr I ...",
  "Image type ID for the image being advertised (should match the image t ...",
  "Firmware version of the image being advertised (should match the versi ...",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginOtaServerUpgradeCommandArguments[] = {
  "Short destination to send message",
  "Endpoint destination to send message",
  "Manufacturer ID for the image (0xFFFF for wildcard)",
  "Image type for the image (0xFFFF for wildcard)",
  "File version for the image (0xFFFFFFFF for wildcard)",
  NULL
};
#endif

static EmberCommandEntry emberCommandTablePluginOtaServerCommands[] = {
#if defined(EMBER_TEST)
  emberCommandEntryActionWithDetails("load-file", emAfOtaLoadFileCommand, "b", "Load file.", emberCommandTablePluginOtaServerLoadFileCommandArguments),
#endif
  emberCommandEntryActionWithDetails("notify", otaImageNotifyCommand, "vuuuvvw", "Sends an OTA Image Notify message to the specified destination indicat ...", emberCommandTablePluginOtaServerNotifyCommandArguments),
  emberCommandEntrySubMenu("policy", emberCommandTablePluginOtaServerPolicyCommands, ""),
  emberCommandEntryActionWithDetails("upgrade", otaSendUpgradeCommand, "vuvvw", "Instruct a device to upgrade now.", emberCommandTablePluginOtaServerUpgradeCommandArguments),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginNetworkCreatorSecurityOpenWithKeyCommandArguments[] = {
  "The EUI64 of the joining device.",
  "The link key that the joining device will use to enter the network.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginNetworkCreatorSecuritySetJoiningLinkKeyCommandArguments[] = {
  "The EUI64 of the joining device.",
  "The link key that the joining device will use to enter the network.",
  NULL
};
#endif

static EmberCommandEntry emberCommandTablePluginNetworkCreatorSecurityCommands[] = {
  emberCommandEntryActionWithDetails("clear-joining-link-keys", emAfPluginNetworkCreatorSecurityClearJoiningLinkKeyCommand, "", "Clear all of the joining link keys stored in the stack.", NULL),
  emberCommandEntryActionWithDetails("close-network", emAfPluginNetworkCreatorSecurityOpenOrCloseNetworkCommand, "", "Close the network for joining.", NULL),
  emberCommandEntryActionWithDetails("open-network", emAfPluginNetworkCreatorSecurityOpenOrCloseNetworkCommand, "", "Open the network for joining.", NULL),
  emberCommandEntryActionWithDetails("open-with-key", emAfPluginNetworkCreatorSecurityOpenNetworkWithKeyCommand, "bb", "Open the network that would only allow the node with specified EUI and ...", emberCommandTablePluginNetworkCreatorSecurityOpenWithKeyCommandArguments),
  emberCommandEntryActionWithDetails("set-joining-link-key", emAfPluginNetworkCreatorSecuritySetJoiningLinkKeyCommand, "bb", "Set the link key that a specific joining device will use when joining  ...", emberCommandTablePluginNetworkCreatorSecuritySetJoiningLinkKeyCommandArguments),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginNetworkCreatorMaskAddCommandArguments[] = {
  "The mask of choice to which to add the channe ...",
  "The channel to add to the channel mask.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginNetworkCreatorMaskSetCommandArguments[] = {
  "The mask of choice to se ...",
  "The bit mask to which to set the chosen channel mask.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginNetworkCreatorMaskSubtractCommandArguments[] = {
  "The mask of choice from which to subtract the channe ...",
  "The channel to subtract from the channel mask.",
  NULL
};
#endif

static EmberCommandEntry emberCommandTablePluginNetworkCreatorMaskCommands[] = {
  emberCommandEntryActionWithDetails("add", emberAfPluginNetworkCreatorChannelMaskCommand, "uw", "Add a channel to the channel mask of choice.", emberCommandTablePluginNetworkCreatorMaskAddCommandArguments),
  emberCommandEntryActionWithDetails("set", emberAfPluginNetworkCreatorChannelMaskCommand, "uw", "Set a channel mask.", emberCommandTablePluginNetworkCreatorMaskSetCommandArguments),
  emberCommandEntryActionWithDetails("subtract", emberAfPluginNetworkCreatorChannelMaskCommand, "uw", "Subtract a channel from the channel mask of choice.", emberCommandTablePluginNetworkCreatorMaskSubtractCommandArguments),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginNetworkCreatorFormCommandArguments[] = {
  "Whether or not to form a centralized networ ...",
  "PanID of the network to be formed",
  "Tx power of the network to be formed",
  "channel of the network to be formed",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginNetworkCreatorStartCommandArguments[] = {
  "Whether or not to form a centralized networ ...",
  NULL
};
#endif

static EmberCommandEntry emberCommandTablePluginNetworkCreatorCommands[] = {
  emberCommandEntryActionWithDetails("form", emberAfPluginNetworkCreatorFormCommand, "uvsu", "Form a network with specified parameters.", emberCommandTablePluginNetworkCreatorFormCommandArguments),
  emberCommandEntrySubMenu("mask", emberCommandTablePluginNetworkCreatorMaskCommands, ""),
  emberCommandEntryActionWithDetails("start", emberAfPluginNetworkCreatorStartCommand, "u", "Starts the network formation process.", emberCommandTablePluginNetworkCreatorStartCommandArguments),
  emberCommandEntryActionWithDetails("status", emberAfPluginNetworkCreatorStatusCommand, "", "Print the status of the network-creator plugin.", NULL),
  emberCommandEntryActionWithDetails("stop", emberAfPluginNetworkCreatorStop, "", "Stops the network formation process.", NULL),
  emberCommandEntryTerminator()
};

static EmberCommandEntry emberCommandTablePluginIasZoneClientCommands[] = {
  emberCommandEntryActionWithDetails("clear-all", emAfPluginIasZoneClientClearAllServersCommand, "", "Clear all known IAS Zone Servers from local device.", NULL),
  emberCommandEntryActionWithDetails("print-servers", emAfPluginIasZoneClientPrintServersCommand, "", "Print the known IAS Zone Servers.", NULL),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginGreenPowerClientAddGroupSinkCommandArguments[] = {
  "GPD Source ID",
  "Sink group",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginGreenPowerClientAddSinkCommandArguments[] = {
  "GPD Source ID",
  "Sink's IEEE address",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginGreenPowerClientDuplicateFilterTestCommandArguments[] = {
  "endpoint",
  "source Id of the fake incoming message",
  "sequence number",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginGreenPowerClientRmGpdCommandArguments[] = {
  "GPD Source ID",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginGreenPowerClientRmSinkCommandArguments[] = {
  "GPD Source ID",
  "Sink's IEEE address",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginGreenPowerClientSetKeyCommandArguments[] = {
  "index",
  "source Id of the fake incoming message",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginGreenPowerClientSetProxyEntryCommandArguments[] = {
  "index to proxy table",
  "GPD Source ID",
  "Sink's node address",
  "options",
  NULL
};
#endif

static EmberCommandEntry emberCommandTablePluginGreenPowerClientCommands[] = {
  emberCommandEntryActionWithDetails("add-group-sink", emberAfPluginGreenPowerClientAddGroupcastSink, "wv", "Add a groupcast sink for a given GPD", emberCommandTablePluginGreenPowerClientAddGroupSinkCommandArguments),
  emberCommandEntryActionWithDetails("add-sink", emberAfPluginGreenPowerClientAddSink, "wb", "Add a sink for a given GPD", emberCommandTablePluginGreenPowerClientAddSinkCommandArguments),
  emberCommandEntryActionWithDetails("clear-proxy-table", emberAfPluginGreenPowerClientClearProxyTable, "", "clear the proxy table", NULL),
  emberCommandEntryActionWithDetails("duplicate-filter-test", emberAfPluginGreenPowerClientDuplicateFilteringTest, "uwu", "This is used to instrument the current device receiving a message in o ...", emberCommandTablePluginGreenPowerClientDuplicateFilterTestCommandArguments),
  emberCommandEntryActionWithDetails("print-proxy-table", emberAfPluginGreenPowerClientPrintProxyTable, "", "Print the proxy table", NULL),
  emberCommandEntryActionWithDetails("rm-gpd", emberAfPluginGreenPowerClientRemoveProxyTableEntry, "w", "Remove a given GPD from the proxy table", emberCommandTablePluginGreenPowerClientRmGpdCommandArguments),
  emberCommandEntryActionWithDetails("rm-sink", emberAfPluginGreenPowerClientAddSink, "wb", "remove a sink for a given GP ...", emberCommandTablePluginGreenPowerClientRmSinkCommandArguments),
  emberCommandEntryActionWithDetails("set-key", emberAfPluginGreenPowerClientSetKey, "ub", "This is used to set the key for a proxy table entry", emberCommandTablePluginGreenPowerClientSetKeyCommandArguments),
  emberCommandEntryActionWithDetails("set-proxy-entry", emberAfPluginGreenPowerClientSetProxyEntry, "uwvw", "Set a proxy table entry", emberCommandTablePluginGreenPowerClientSetProxyEntryCommandArguments),
  emberCommandEntryTerminator()
};

static EmberCommandEntry emberCommandTablePluginGatewayCommands[] = {
  emberCommandEntryActionWithDetails("time-sync-local", emberAfPluginGatewaySupportTimeSyncLocal, "", "This command will sync the ZCL device's local time attribute with the  ...", NULL),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginEzmodeCommissioningClientCommandArguments[] = {
  "The local endpoint.",
  "::EMBER_AF_EZMODE_COMMISSIONING_SERVER_TO_CLIENT or ::EMBER_AF_EZMODE_ ...",
  "A list of cluster ids.",
  "",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginEzmodeCommissioningServerCommandArguments[] = {
  "The local endpoint.",
  "The identify time in seconds.",
  NULL
};
#endif

static EmberCommandEntry emberCommandTablePluginEzmodeCommissioningCommands[] = {
  emberCommandEntryActionWithDetails("client", emberAfPluginEzModeCommissioningClientCommand, "uuv*", "Start EZ-Mode client commissioning.", emberCommandTablePluginEzmodeCommissioningClientCommandArguments),
  emberCommandEntryActionWithDetails("server", emberAfPluginEzModeCommissioningServerCommand, "uv", "Start EZ-Mode server commissioning.", emberCommandTablePluginEzmodeCommissioningServerCommandArguments),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginCountersSetThresholdCommandArguments[] = {
  "type of counter",
  "Threshold Value",
  NULL
};
#endif

static EmberCommandEntry emberCommandTablePluginCountersCommands[] = {
  emberCommandEntryActionWithDetails("clear", emberAfPluginCountersClear, "", "Clear all counter values.", NULL),
  emberCommandEntryActionWithDetails("print", emberAfPluginCountersPrintCommand, "", "Print all counter values and clear them.", NULL),
  emberCommandEntryActionWithDetails("print-thresholds", emberAfPluginCountersPrintThresholdsCommand, "", "Prints the thresholds of all the counters.", NULL),
  emberCommandEntryActionWithDetails("reset-threshold", emberAfPluginCountersResetThresholds, "", "Resets all thresholds values to 0xFFFF.", NULL),
  emberCommandEntryActionWithDetails("send-request", emberAfPluginCountersSendRequestCommand, "", "Sends a request for ota counters", NULL),
  emberCommandEntryActionWithDetails("set-threshold", emberAfPluginCountersSetThresholdCommand, "uv", "Set a threshold value for a particular type of counter.", emberCommandTablePluginCountersSetThresholdCommandArguments),
  emberCommandEntryActionWithDetails("simple-print", emberAfPluginCountersSimplePrintCommand, "", "Print all counter values.", NULL),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginCounterPrintCounterTypeCommandArguments[] = {
  "The counter type       to print.",
  NULL
};
#endif

static EmberCommandEntry emberCommandTablePluginCounterCommands[] = {
  emberCommandEntryActionWithDetails("print-counter-type", emberAfPluginCounterPrintCounterTypeCommand, "u", "Print value of this particular counter.", emberCommandTablePluginCounterPrintCounterTypeCommandArguments),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginConcentratorSetRouterBehaviorCommandArguments[] = {
  "The value of a EMBER_AF_PLUGIN_CONCENTRATOR_ROUTER_BEHAVIOR_ enum memb ...",
  NULL
};
#endif

static EmberCommandEntry emberCommandTablePluginConcentratorCommands[] = {
  emberCommandEntryActionWithDetails("agg", emberAfPluginConcentratorAggregationCommand, "", "(Requires Concentrator Support to be enabled on this devic ...", NULL),
  emberCommandEntryActionWithDetails("print-host-table", emberAfPluginConcentratorPrintHostSourceRouteTable, "", "Print the host source route table.", NULL),
  emberCommandEntryActionWithDetails("print-table", emberAfPluginConcentratorPrintSourceRouteTable, "", "Print the SOC/NCP source route table.", NULL),
  emberCommandEntryActionWithDetails("set-router-behavior", emberAfPluginConcentratorSetRouterBehaviorCommand, "u", "This command allows the user to set the router behavior for this plugi ...", emberCommandTablePluginConcentratorSetRouterBehaviorCommandArguments),
  emberCommandEntryActionWithDetails("start", emberAfPluginConcentratorStartDiscovery, "", "Starts the periodic broadcast of MTORRs", NULL),
  emberCommandEntryActionWithDetails("status", emberAfPluginConcentratorStatus, "", "Prints current status and configured parameters of the concentrator", NULL),
  emberCommandEntryActionWithDetails("stop", emberAfPluginConcentratorStopDiscovery, "", "Stops the periodic broadcast of MTORRs", NULL),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginAddressTableAddCommandArguments[] = {
  "Entry to be added.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginAddressTableLookupCommandArguments[] = {
  "Entry to be looked up.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginAddressTableRemoveCommandArguments[] = {
  "Entry to be removed.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTablePluginAddressTableSetCommandArguments[] = {
  "index",
  "eui64",
  "node id",
  NULL
};
#endif

static EmberCommandEntry emberCommandTablePluginAddressTableCommands[] = {
  emberCommandEntryActionWithDetails("add", emberAfPluginAddressTableAddCommand, "b", "Add an entry to the address table.", emberCommandTablePluginAddressTableAddCommandArguments),
  emberCommandEntryActionWithDetails("lookup", emberAfPluginAddressTableLookupCommand, "b", "Lookup an entry in the address table.", emberCommandTablePluginAddressTableLookupCommandArguments),
  emberCommandEntryActionWithDetails("print", emberAfPluginAddressTablePrintCommand, "", "Prints the address table.", NULL),
  emberCommandEntryActionWithDetails("remove", emberAfPluginAddressTableRemoveCommand, "b", "Remove an entry from the address table.", emberCommandTablePluginAddressTableRemoveCommandArguments),
  emberCommandEntryActionWithDetails("set", emberAfPluginAddressTableSetCommand, "ubv", "Set an entry in the address table according to the arguments specified", emberCommandTablePluginAddressTableSetCommandArguments),
  emberCommandEntryTerminator()
};

static EmberCommandEntry emberCommandTablePluginCommands[] = {
  emberCommandEntrySubMenu("address-table", emberCommandTablePluginAddressTableCommands, ""),
  emberCommandEntrySubMenu("concentrator", emberCommandTablePluginConcentratorCommands, ""),
  emberCommandEntrySubMenu("counter", emberCommandTablePluginCounterCommands, ""),
  emberCommandEntrySubMenu("counters", emberCommandTablePluginCountersCommands, ""),
  emberCommandEntrySubMenu("ezmode-commissioning", emberCommandTablePluginEzmodeCommissioningCommands, ""),
  emberCommandEntrySubMenu("gateway", emberCommandTablePluginGatewayCommands, ""),
  emberCommandEntrySubMenu("green-power-client", emberCommandTablePluginGreenPowerClientCommands, ""),
  emberCommandEntrySubMenu("ias-zone-client", emberCommandTablePluginIasZoneClientCommands, ""),
  emberCommandEntrySubMenu("network-creator", emberCommandTablePluginNetworkCreatorCommands, ""),
  emberCommandEntrySubMenu("network-creator-security", emberCommandTablePluginNetworkCreatorSecurityCommands, ""),
  emberCommandEntrySubMenu("ota-server", emberCommandTablePluginOtaServerCommands, ""),
  emberCommandEntrySubMenu("ota-storage-common", emberCommandTablePluginOtaStorageCommonCommands, ""),
  emberCommandEntrySubMenu("poll-control-client", emberCommandTablePluginPollControlClientCommands, ""),
  emberCommandEntrySubMenu("reporting", emberCommandTablePluginReportingCommands, ""),
  emberCommandEntrySubMenu("simple-metering-client", emberCommandTablePluginSimpleMeteringClientCommands, ""),
  emberCommandEntrySubMenu("stack-diagnostics", emberCommandTablePluginStackDiagnosticsCommands, ""),
  emberCommandEntrySubMenu("test-harness", emberCommandTablePluginTestHarnessCommands, ""),
  emberCommandEntrySubMenu("trust-center-backup", emberCommandTablePluginTrustCenterBackupCommands, ""),
  emberCommandEntryTerminator()
};

static EmberCommandEntry emberCommandTableOptionSecurityApsCommands[] = {
  emberCommandEntryActionWithDetails("off", optionApsSecurityCommand, "", "Turns aps security off", NULL),
  emberCommandEntryActionWithDetails("on", optionApsSecurityCommand, "", "Turns aps security on", NULL),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableOptionSecuritySetAllowTrustCenterRejoinUsingWellKnownKeyCommandArguments[] = {
  "Whether or not the Trust Center should allow trust center rejoins for  ...",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableOptionSecuritySetAllowTrustCenterRejoinUsingWellKnownKeyTimeoutCommandArguments[] = {
  "The number of seconds that trust center rejoins will be responded to u ...",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableOptionSecuritySetKeyRequestPolicyCommandArguments[] = {
  "The value to assign to emberTrustCenterLinkKeyRequestPolicy",
  "The value to assign to emberAppLinkKeyRequestPolicy",
  NULL
};
#endif

static EmberCommandEntry emberCommandTableOptionSecurityCommands[] = {
  emberCommandEntrySubMenu("aps", emberCommandTableOptionSecurityApsCommands, ""),
  emberCommandEntryActionWithDetails("set-allow-trust-center-rejoin-using-well-known-key", optionSecurityAllowTrustCenterRejoinUsingWellKnownKey, "u", "Set whether or not a Trust Center application will allow trust center  ...", emberCommandTableOptionSecuritySetAllowTrustCenterRejoinUsingWellKnownKeyCommandArguments),
  emberCommandEntryActionWithDetails("set-allow-trust-center-rejoin-using-well-known-key-timeout", optionSecurityAllowTrustCenterRejoinUsingWellKnownKeyTimeout, "v", "Sets the number of seconds to allow trust center rejoins for devices u ...", emberCommandTableOptionSecuritySetAllowTrustCenterRejoinUsingWellKnownKeyTimeoutCommandArguments),
  emberCommandEntryActionWithDetails("set-key-request-policy", optionSecuritySetKeyRequestPolicy, "uu", "Sets the local policy for handling TC link key requests and applicatio ...", emberCommandTableOptionSecuritySetKeyRequestPolicyCommandArguments),
  emberCommandEntryTerminator()
};

static EmberCommandEntry emberCommandTableOptionPrintRxMsgsCommands[] = {
  emberCommandEntryActionWithDetails("disable", optionPrintRxCommand, "", "Disable the printing of received messages.", NULL),
  emberCommandEntryActionWithDetails("enable", optionPrintRxCommand, "", "Enable the printing of received messages.", NULL),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableOptionBindingTableSetCommandArguments[] = {
  "one byte index into the binding table",
  "cluster id to send with the discovery message",
  "local endpoint to bind",
  "remote endpoint to bind",
  "8 byte IEEE address provided big endian",
  NULL
};
#endif

static EmberCommandEntry emberCommandTableOptionBindingTableCommands[] = {
  emberCommandEntryActionWithDetails("clear", optionBindingTableClearCommand, "", "Clear the binding table", NULL),
  emberCommandEntryActionWithDetails("print", optionBindingTablePrintCommand, "", "Prints out the binding table to the command line.", NULL),
  emberCommandEntryActionWithDetails("set", optionBindingTableSetCommand, "uvuub", "Set a binding table entry for the arguments specified.", emberCommandTableOptionBindingTableSetCommandArguments),
  emberCommandEntryTerminator()
};

static EmberCommandEntry emberCommandTableOptionApsretryCommands[] = {
  emberCommandEntryActionWithDetails("default", optionApsRetryCommand, "", "Forces the AppFramework to set/clear the APS Retry option (in APS Fram ...", NULL),
  emberCommandEntryActionWithDetails("off", optionApsRetryCommand, "", "Forces the AppFramework to set/clear the APS Retry option (in APS Fram ...", NULL),
  emberCommandEntryActionWithDetails("on", optionApsRetryCommand, "", "Forces the AppFramework to set/clear the APS Retry option (in APS Fram ...", NULL),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableOptionDiscCommandArguments[] = {
  "the profile id to send with the discovery message",
  "cluster id to send with the discovery message",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableOptionEdbCommandArguments[] = {
  "The local endpoint whose simple descriptor will be used to create the  ...",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD) && !defined(EMBER_AF_HAS_SECURITY_PROFILE_NONE)
static const char * const emberCommandTableOptionInstallCodeCommandArguments[] = {
  "index into the link key table",
  "IEEE address to enter into the link key table",
  "install code including two-byte, little-endian CRC",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableOptionLinkCommandArguments[] = {
  "index into the link key table",
  "IEEE address to enter into the link key table",
  "link key to enter into the table",
  NULL
};
#endif

static EmberCommandEntry emberCommandTableOptionCommands[] = {
  emberCommandEntrySubMenu("apsretry", emberCommandTableOptionApsretryCommands, ""),
  emberCommandEntrySubMenu("binding-table", emberCommandTableOptionBindingTableCommands, ""),
  emberCommandEntryActionWithDetails("disc", optionDiscoverCommand, "vv", "Sends a ZDO Match Descriptor Request for the server side of the specif ...", emberCommandTableOptionDiscCommandArguments),
  emberCommandEntryActionWithDetails("edb", optionEndDeviceBindCommand, "u", "Sends a ZDO End Device Bind Request using the given local endpoint.", emberCommandTableOptionEdbCommandArguments),
#if !defined(EMBER_AF_HAS_SECURITY_PROFILE_NONE)
  emberCommandEntryActionWithDetails("install-code", optionInstallCodeCommand, "ubb", "Derives a link key from an install code and sets it in the link key ta ...", emberCommandTableOptionInstallCodeCommandArguments),
#endif
  emberCommandEntryActionWithDetails("link", optionLinkCommand, "ubb", "Sets a link key in the link key tabl ...", emberCommandTableOptionLinkCommandArguments),
  emberCommandEntrySubMenu("print-rx-msgs", emberCommandTableOptionPrintRxMsgsCommands, ""),
  emberCommandEntryActionWithDetails("register", optionRegisterCommand, "", "Initiates Smart Energy Registration including Key Establishmen ...", NULL),
  emberCommandEntrySubMenu("security", emberCommandTableOptionSecurityCommands, ""),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableNetworkFindMaskCommandArguments[] = {
  "channel page (0 and 28-31, if sub-GHz support is included)",
  "channel mask",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableNetworkFindModeCommandArguments[] = {
  "Bit 0 = enable 2.4GHz, Bit 1 = enable sub-GHz",
  NULL
};
#endif

static EmberCommandEntry emberCommandTableNetworkFindCommands[] = {
  emberCommandEntryActionWithDetails("joinable", findJoinableNetworkCommand, "", "Begin a search for a joinable networ ...", NULL),
  emberCommandEntryActionWithDetails("mask", findMaskCommand, "uw", "Set a channel mask for a given channel page for 'find joinable' and 'f ...", emberCommandTableNetworkFindMaskCommandArguments),
  emberCommandEntryActionWithDetails("mode", findModeCommand, "u", "Set a search mode for 'find joinable' and 'find unused'.", emberCommandTableNetworkFindModeCommandArguments),
  emberCommandEntryActionWithDetails("print", findPrintCommand, "", "Print network search parameters (mode and channel masks).", NULL),
  emberCommandEntryActionWithDetails("unused", findUnusedPanIdCommand, "", "Begin a search for an unused Channel and Pan I ...", NULL),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableNetworkBroadPjoinCommandArguments[] = {
  "Number of seconds during which devices will be allowed to join the net ...",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableNetworkChangeChannelCommandArguments[] = {
  "The channel to change to.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableNetworkExtpanidCommandArguments[] = {
  "The bytes for the extended pan id",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableNetworkFormCommandArguments[] = {
  "The channel on which to form the network",
  "One byte signed value indicating the TX power that the radio should be ...",
  "Two byte pan id for the network",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableNetworkJoinCommandArguments[] = {
  "The channel on which to form the network",
  "One byte signed value indicating the TX power that the radio should be ...",
  "Two byte pan id for the network",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableNetworkMultiPhyStartCommandArguments[] = {
  "The page on which to form the network.",
  "The channel on which to form the network.",
  "One byte signed value indicating the TX power that the radio should be ...",
  "",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableNetworkPjoinCommandArguments[] = {
  "Number of seconds during which devices will be allowed to join the net ...",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableNetworkRejoinCommandArguments[] = {
  "Boolean indicating whether the device can rejoin secure or no ...",
  "4 byte channel mask which should be used to search for the network to  ...",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableNetworkRejoinDiffDeviceTypeCommandArguments[] = {
  "Boolean indicating whether the device can rejoin secure or no ...",
  "4 byte channel mask which should be used to search for the network to  ...",
  "An enumeration indicating the device type to rejoin a ...",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableNetworkSetCommandArguments[] = {
  "The network index to use for CLI commands",
  NULL
};
#endif

static EmberCommandEntry emberCommandTableNetworkCommands[] = {
  emberCommandEntryActionWithDetails("broad-pjoin", networkPermitJoinCommand, "u", "Permit joining on the network for a given number of seconds AND broadc ...", emberCommandTableNetworkBroadPjoinCommandArguments),
  emberCommandEntryActionWithDetails("change-channel", networkChangeChannelCommand, "u", "Attempts to change device over to a different channel given in the cha ...", emberCommandTableNetworkChangeChannelCommandArguments),
  emberCommandEntryActionWithDetails("extpanid", networkExtendedPanIdCommand, "b", "Write the extended pan id for the device.", emberCommandTableNetworkExtpanidCommandArguments),
  emberCommandEntrySubMenu("find", emberCommandTableNetworkFindCommands, ""),
  emberCommandEntryActionWithDetails("form", networkFormCommand, "usv", "Create a network on the given channel, power and panId.", emberCommandTableNetworkFormCommandArguments),
  emberCommandEntryActionWithDetails("id", networkIdCommand, "", "Prints the current Node ID, EUI64, and Pan ID.", NULL),
  emberCommandEntryActionWithDetails("init", networkInitCommand, "", "Initialize a network; this is a test command used for tc-swap-out test ...", NULL),
  emberCommandEntryActionWithDetails("join", networkJoinCommand, "usv", "Join an existing network on the given channel, power and panId.", emberCommandTableNetworkJoinCommandArguments),
  emberCommandEntryActionWithDetails("leave", networkLeaveCommand, "", "Leave the current network.", NULL),
  emberCommandEntryActionWithDetails("multi-phy-start", networkMultiPhyStartCommand, "uus*", "To start multi phy interface other than native and form the networ ...", emberCommandTableNetworkMultiPhyStartCommandArguments),
  emberCommandEntryActionWithDetails("multi-phy-stop", networkMultiPhyStopCommand, "", "Terminates the multi phy interface", NULL),
  emberCommandEntryActionWithDetails("pjoin", networkPermitJoinCommand, "u", "Permit joining on the network for a given number of seconds", emberCommandTableNetworkPjoinCommandArguments),
  emberCommandEntryActionWithDetails("rejoin", networkRejoinCommand, "uw", "Rejoin an existing network in a secure or insecure manner.", emberCommandTableNetworkRejoinCommandArguments),
  emberCommandEntryActionWithDetails("rejoin-diff-device-type", networkRejoinDiffDeviceTypeCommand, "uwu", "Rejoin an existing network in a secure or insecure manner with a diffe ...", emberCommandTableNetworkRejoinDiffDeviceTypeCommandArguments),
  emberCommandEntryActionWithDetails("set", networkSetCommand, "u", "Set the network index used by all future CLI command ...", emberCommandTableNetworkSetCommandArguments),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableKeysDeleteCommandArguments[] = {
  "index into the security key table",
  NULL
};
#endif

static EmberCommandEntry emberCommandTableKeysCommands[] = {
  emberCommandEntryActionWithDetails("clear", keysClearCommand, "", "Clear all security keys", NULL),
  emberCommandEntryActionWithDetails("delete", keysDeleteCommand, "u", "Delete a security key from a given index", emberCommandTableKeysDeleteCommandArguments),
  emberCommandEntryActionWithDetails("print", keysPrintCommand, "", "Print all security keys out to the command line.", NULL),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableInterpanGroupCommandArguments[] = {
  "group id to send to",
  "destination pan id",
  "destination profile ID",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableInterpanLongCommandArguments[] = {
  "long ieee address to send the interpan message to",
  "two byte destination PA ID",
  "two byte destination profile ID",
  "two byte options",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableInterpanShortCommandArguments[] = {
  "group id to send to",
  "destination pan id",
  "destination profile ID",
  NULL
};
#endif

static EmberCommandEntry emberCommandTableInterpanCommands[] = {
  emberCommandEntryActionWithDetails("group", interpanCommand, "vvv", "send an interpan message to a group id.", emberCommandTableInterpanGroupCommandArguments),
  emberCommandEntryActionWithDetails("long", interpanLongCommand, "bvvv", "Send an interpan message to a long address (8 byte eui64)", emberCommandTableInterpanLongCommandArguments),
  emberCommandEntryActionWithDetails("short", interpanCommand, "vvv", "Send an interpan message to a short id.", emberCommandTableInterpanShortCommandArguments),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableEndpointDisableCommandArguments[] = {
  "Endpoint in question.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableEndpointEnableCommandArguments[] = {
  "Endpoint in question.",
  NULL
};
#endif

static EmberCommandEntry emberCommandTableEndpointCommands[] = {
  emberCommandEntryActionWithDetails("disable", enableDisableEndpoint, "u", "Disable the endpoint for processing ZCL messages.", emberCommandTableEndpointDisableCommandArguments),
  emberCommandEntryActionWithDetails("enable", enableDisableEndpoint, "u", "Enable the endpoint for processing ZCL messages.", emberCommandTableEndpointEnableCommandArguments),
  emberCommandEntryActionWithDetails("print", endpointPrint, "", "Print the status of all the endpoints.", NULL),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableDebugprintOffCommandArguments[] = {
  "The debug area mask listed in the <application>.h file",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableDebugprintOnCommandArguments[] = {
  "The debug area mask listed in the <application>.h file",
  NULL
};
#endif

static EmberCommandEntry emberCommandTableDebugprintCommands[] = {
  emberCommandEntryActionWithDetails("all_off", emberAfPrintAllOff, "", "Turns off all debug printing", NULL),
  emberCommandEntryActionWithDetails("all_on", emberAfPrintAllOn, "", "Turns on all compiled in debug printing", NULL),
  emberCommandEntryActionWithDetails("off", printOffCommand, "u", "Turns off compiled in debug printing for a specific debug printing are ...", emberCommandTableDebugprintOffCommandArguments),
  emberCommandEntryActionWithDetails("on", printOnCommand, "u", "Turns on compiled in debug printing for a specific debug printing area ...", emberCommandTableDebugprintOnCommandArguments),
  emberCommandEntryActionWithDetails("status", emberAfPrintStatus, "", "Prints out the current settings for debug printing on the device", NULL),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableChangekeyLinkCommandArguments[] = {
  "The link key provided as a 16 byte array",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableChangekeyNetworkCommandArguments[] = {
  "The network key provided as a 16 byte array",
  NULL
};
#endif

static EmberCommandEntry emberCommandTableChangekeyCommands[] = {
  emberCommandEntryActionWithDetails("link", changeKeyCommand, "b", "Change the link key to the one provided in the 16 byte array argument  ...", emberCommandTableChangekeyLinkCommandArguments),
  emberCommandEntryActionWithDetails("network", changeKeyCommand, "b", "Change the network key to the 16 byte array provided as an argument to ...", emberCommandTableChangekeyNetworkCommandArguments),
  emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableBsendCommandArguments[] = {
  "Source endpoint to send a binding based message from",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableEchoCommandArguments[] = {
  "bool indicating whether to turn echo on (1) or off (0)",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableRawCommandArguments[] = {
  "two byte cluster id",
  "ZCL message, including ZCL header and payload",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableReadCommandArguments[] = {
  "endpoint of the attribute to read",
  "cluster id of the attribute to read",
  "attribute id of the attribute to read",
  "direction mask of the attribute to read (client=0 or server=1)",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableSendCommandArguments[] = {
  "short id of the device to send the message to",
  "The endpoint to send the message from",
  "The endpoint to send the message to",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableSendUsingMulticastBindingCommandArguments[] = {
  "Whether to send via a multicast binding",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableSendMulticastCommandArguments[] = {
  "group id of the multicast group to send the message to",
  "The endpoint to send the message from",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableTimesyncCommandArguments[] = {
  "two byte short id of the time server",
  "source endpoint to send time sync from",
  "destination endpoint to expect response on",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static const char * const emberCommandTableWriteCommandArguments[] = {
  "endpoint of the attribute to write",
  "cluster id of the attribute to write",
  "attribute id of the attribute to write",
  "direction mask of the attribute to write (client=0 or server=1)",
  "the attribute type as listed in the generated file attribute-type.h",
  "string of bytes you wish to write into the attribute table.",
  NULL
};
#endif

EmberCommandEntry emberCommandTable[] = {
  emberCommandEntryActionWithDetails("bsend", emAfCliBsendCommand, "u", "Send using a binding based on the clusterId in the globalApsFrame and  ...", emberCommandTableBsendCommandArguments),
  emberCommandEntrySubMenu("changekey", emberCommandTableChangekeyCommands, ""),
  emberCommandEntrySubMenu("debugprint", emberCommandTableDebugprintCommands, ""),
  emberCommandEntryActionWithDetails("echo", echoCommand, "u", "Turns echo on the command line on or off depending on the argument", emberCommandTableEchoCommandArguments),
  emberCommandEntrySubMenu("endpoint", emberCommandTableEndpointCommands, ""),
  emberCommandEntryActionWithDetails("events", printEvents, "", "Print the list of timer events.", NULL),
  emberCommandEntryActionWithDetails("help", helpCommand, "", "Prints out the cli command options for the device", NULL),
  emberCommandEntryActionWithDetails("info", emAfCliInfoCommand, "", "Gives information about the local node", NULL),
  emberCommandEntrySubMenu("interpan", emberCommandTableInterpanCommands, ""),
  emberCommandEntrySubMenu("keys", emberCommandTableKeysCommands, ""),
  emberCommandEntryActionWithDetails("libs", printAllLibraryStatus, "", "Lists which optional libraries of the stack are implemented on this de ...", NULL),
  emberCommandEntrySubMenu("network", emberCommandTableNetworkCommands, ""),
  emberCommandEntrySubMenu("option", emberCommandTableOptionCommands, ""),
  emberCommandEntrySubMenu("plugin", emberCommandTablePluginCommands, ""),
  emberCommandEntrySubMenu("print", emberCommandTablePrintCommands, ""),
  emberCommandEntryActionWithDetails("raw", emAfCliRawCommand, "vb", "Creates a message by specifying the raw byte ...", emberCommandTableRawCommandArguments),
  emberCommandEntryActionWithDetails("read", emAfCliReadCommand, "uvvu", "Read an attribute from the local attribute tabl ...", emberCommandTableReadCommandArguments),
  emberCommandEntryActionWithDetails("reset", resetCommand, "", "resets the device", NULL),
  emberCommandEntrySubMenu("security", emberCommandTableSecurityCommands, ""),
  emberCommandEntryActionWithDetails("send", emAfCliSendCommand, "vuu", "Send a pre-buffered message from a given endpoint to an endpoint on a  ...", emberCommandTableSendCommandArguments),
  emberCommandEntryActionWithDetails("send-using-multicast-binding", emAfCliSendUsingMulticastBindingCommand, "u", "When sending using a binding, specify whether a multicast binding shou ...", emberCommandTableSendUsingMulticastBindingCommandArguments),
  emberCommandEntryActionWithDetails("send_multicast", emAfCliSendCommand, "vu", "Send a pre-buffered multicast message to a given group id from a given ...", emberCommandTableSendMulticastCommandArguments),
  emberCommandEntryActionWithDetails("timesync", emAfCliTimesyncCommand, "vuu", "This sends a read attr for the time of the device specifie ...", emberCommandTableTimesyncCommandArguments),
  emberCommandEntryActionWithDetails("version", emAfCliVersionCommand, "", "Shows the version of the software", NULL),
  emberCommandEntryActionWithDetails("write", emAfCliWriteCommand, "uvvuub", "Write an attribute value into the local attribute table", emberCommandTableWriteCommandArguments),
  emberCommandEntrySubMenu("zcl", emberCommandTableZclCommands, ""),
  emberCommandEntrySubMenu("zdo", emberCommandTableZdoCommands, ""),
  CUSTOM_COMMANDS
  emberCommandEntryTerminator()
};