// 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 emAfDeviceTableDiscoverPresentNodeCommand(void);
void emAfDeviceTableIndexRemoveCommand(void);
void emAfDeviceTableIndexRouteRepairCommand(void);
void emAfDeviceTableIndexSendCommand(void);
void emAfDeviceTableLoadCommand(void);
void emAfDeviceTableRemoveCommand(void);
void emAfDeviceTableRouteRepairCommand(void);
void emAfDeviceTableSaveCommand(void);
void emAfDeviceTableSendCommand(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 emAfPluginCommandRelayAddCommand(void);
void emAfPluginCommandRelayClearCommand(void);
void emAfPluginCommandRelayLoadCommand(void);
void emAfPluginCommandRelayPrintCommand(void);
void emAfPluginCommandRelayRemoveCommand(void);
void emAfPluginCommandRelaySaveCommand(void);
void emAfPluginDeviceTableSendLeaveCommand(void);
void emAfPluginIasZoneClientClearAllServersCommand(void);
void emAfPluginIasZoneClientPrintServersCommand(void);
void emAfPluginIdentifyCliPrint(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 emberAfDeviceTableClear(void);
void emberAfDeviceTablePrintDeviceTable(void);
void emberAfPluginAddressTableAddCommand(void);
void emberAfPluginAddressTableLookupCommand(void);
void emberAfPluginAddressTablePrintCommand(void);
void emberAfPluginAddressTableRemoveCommand(void);
void emberAfPluginAddressTableSetCommand(void);
void emberAfPluginButtonJoiningButton0Command(void);
void emberAfPluginButtonJoiningButton1Command(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 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 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 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);
}

void zclIdentifyOnOffCommand(void);
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 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);
void zclUseNextSequenceCommand(void);
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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM emberCommandTableZdoNwkUpdChanCommandArguments[] = {
  "One byte channel to change to.",
  NULL
};
#endif

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

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM emberCommandTableZdoActiveCommandArguments[] = {
	"Two byte short id, destination for the active endpoint request",
	NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM emberCommandTableZdoIeeeCommandArguments[] = {
  "Short address of the device for which a long address is requested",
  NULL
};
#endif

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

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM emberCommandTableZdoMgmtBindCommandArguments[] = {
	"Target node ID",
	"Starting index into table query",
	NULL
};
#endif

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

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

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

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

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM 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()
};

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 PGM_P PGM emberCommandTableZclScenesAddCommandArguments[] = {
  "group id",
  "scene id",
  "transition time",
  "scene name",
  "extension field sets",
  "",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM emberCommandTableZclScenesEaddCommandArguments[] = {
  "group id",
  "scene id",
  "transition time",
  "scene name",
  "extension field sets",
  "",
  NULL
};
#endif

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

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

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

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

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

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

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM emberCommandTableZclPollControlLongCommandArguments[] = {
  "new long poll interval",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM emberCommandTableZclOtaConfigReadCommandArguments[] = {
  "token",
  NULL
};
#endif

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

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM emberCommandTableZclOnOffOffeffectCommandArguments[] = {
  "effect id",
  "effect variant",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM emberCommandTableZclMfglibRxModeCommandArguments[] = {
  "channel",
  "power",
  "time",
  NULL
};
#endif

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

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM emberCommandTableZclMeteringGetProfileCommandArguments[] = {
  "interval channel",
  "end time",
  "number of periods",
  NULL
};
#endif

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

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

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

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

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

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

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

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM emberCommandTableZclLevelControlMoveCommandArguments[] = {
  "move mode",
  "rate",
  "option mask",
  "option override",
  NULL
};
#endif

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

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

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

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

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

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM emberCommandTableZclIdentifyEzModeCommandArguments[] = {
  "action",
  NULL
};
#endif

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

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM emberCommandTableZclIdentifyOffCommandArguments[] = {
  "The endpoint on which to stop identifying",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM emberCommandTableZclIdentifyOnCommandArguments[] = {
  "The endpoint on the device which should begin identifying",
  "The number of seconds to spend identifying",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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("off", zclIdentifyOnOffCommand, "u", "Writes the IdentifyTime attribute", emberCommandTableZclIdentifyOffCommandArguments),
	emberCommandEntryActionWithDetails("on", zclIdentifyOnOffCommand, "uv", "Writes the IdentifyTime attribute", emberCommandTableZclIdentifyOnCommandArguments),
	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 PGM_P PGM emberCommandTableZclGroupsAddCommandArguments[] = {
  "group id",
  "group name",
  NULL
};
#endif

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

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

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

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM emberCommandTableZclGlobalDirectionCommandArguments[] = {
  "The direction for global commands, 0 = client to server, 1 = server to ...",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM emberCommandTableZclGlobalReportCommandArguments[] = {
  "The desired endpoint.",
  "The cluster id.",
  "The attribute id.",
  "The mask.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM emberCommandTableZclColorControlEmovehueCommandArguments[] = {
  "move mode",
  "rate",
  NULL
};
#endif

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

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

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

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

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

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM emberCommandTableZclColorControlMovehueCommandArguments[] = {
  "move mode",
  "rate",
  "options mask",
  "options override",
  NULL
};
#endif

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

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

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

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

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

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

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

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM emberCommandTableZclColorControlStephueCommandArguments[] = {
  "step mode",
  "step size",
  "transition time",
  "options mask",
  "options override",
  NULL
};
#endif

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

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM emberCommandTableZclBasicGlsCommandArguments[] = {
  "start locale",
  "max locales requested",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM emberCommandTableZclMfgCodeCommandArguments[] = {
	"Manufacturer Specific Id",
	NULL
};
#endif

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

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

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

static EmberCommandEntry emberCommandTableZclCommands[] = {
	emberCommandEntrySubMenu("basic", emberCommandTableZclBasicCommands, ""),
	emberCommandEntrySubMenu("color-control", emberCommandTableZclColorControlCommands, ""),
  emberCommandEntrySubMenu("global", emberCommandTableZclGlobalCommands, ""),
	emberCommandEntrySubMenu("groups", emberCommandTableZclGroupsCommands, ""),
	emberCommandEntrySubMenu("identify", emberCommandTableZclIdentifyCommands, ""),
	emberCommandEntrySubMenu("level-control", emberCommandTableZclLevelControlCommands, ""),
	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),
	emberCommandEntryActionWithDetails("use-next-sequence", zclUseNextSequenceCommand, "u", "Sets the flag to use the incremented sequence number from the framewor ...", emberCommandTableZclUseNextSequenceCommandArguments),
	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 PGM_P PGM 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 emberCommandTablePrintCommands[] = {
	emberCommandEntryActionWithDetails("attr", emberAfPrintAttributeTable, "", "Print the attribute table.", NULL),
	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 PGM_P PGM emberCommandTablePluginTrustCenterBackupFileExportCommandArguments[] = {
  "path",
  NULL
};
#endif

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

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

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM emberCommandTablePluginTestHarnessPriceSendNewFieldsCommandArguments[] = {
  "Boolean indicating whether to send new fields.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM emberCommandTablePluginTestHarnessKeyEstablishmentCertMangleCorruptCommandArguments[] = {
  "The index of the certificate byte to corrupt",
  NULL
};
#endif

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

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

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM emberCommandTablePluginTestHarnessKeyEstablishmentKeyMangleCommandArguments[] = {
  "The positive or negative change in length.",
  NULL
};
#endif

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

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

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

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM emberCommandTablePluginTestHarnessEndpointDisableCommandArguments[] = {
  "The endpoint number.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM emberCommandTablePluginTestHarnessAttrOptionsCommandArguments[] = {
  "type",
  "timeout",
  NULL
};
#endif

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

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM emberCommandTablePluginTestHarnessSetComplianceRevisionCommandArguments[] = {
  "The compliance version",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM emberCommandTablePluginPollControlClientModeCommandArguments[] = {
  "The fast polling mode.",
  NULL
};
#endif

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

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM emberCommandTablePluginOtaServerPolicyClientDelayUnitsCommandArguments[] = {
  "The unit to treat the minimum block period field.",
  NULL
};
#endif

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

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM emberCommandTablePluginOtaServerLoadFileCommandArguments[] = {
  "The file name.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 emberCommandTablePluginIdentifyCommands[] = {
	emberCommandEntryActionWithDetails("print", emAfPluginIdentifyCliPrint, "", "Print which endpoints are reporting.", 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 PGM_P PGM emberCommandTablePluginGreenPowerClientAddGroupSinkCommandArguments[] = {
  "GPD Source ID",
  "Sink group",
  NULL
};
#endif

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

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

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

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

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

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM emberCommandTablePluginDeviceTableDiscCommandArguments[] = {
  "Node ID to discover.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM emberCommandTablePluginDeviceTableIremoveCommandArguments[] = {
  "Device table index.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM emberCommandTablePluginDeviceTableIrepairCommandArguments[] = {
  "Device table index.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM emberCommandTablePluginDeviceTableIsendCommandArguments[] = {
  "Device table index.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM emberCommandTablePluginDeviceTableLeaveCommandArguments[] = {
  "EUI64 of device.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM emberCommandTablePluginDeviceTableRemoveCommandArguments[] = {
  "EUI64 of device.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM emberCommandTablePluginDeviceTableRepairCommandArguments[] = {
  "EUI64 of device.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM emberCommandTablePluginDeviceTableSendCommandArguments[] = {
  "EUI64 of device.",
  "Endpoint of device.",
  NULL
};
#endif

static EmberCommandEntry emberCommandTablePluginDeviceTableCommands[] = {
	emberCommandEntryActionWithDetails("clear", emberAfDeviceTableClear, "", "Clear the device table", NULL),
	emberCommandEntryActionWithDetails("disc", emAfDeviceTableDiscoverPresentNodeCommand, "v", "Force a (re)discovery of the device based on the node ID.", emberCommandTablePluginDeviceTableDiscCommandArguments),
	emberCommandEntryActionWithDetails("iremove", emAfDeviceTableIndexRemoveCommand, "v", "Remove device from device table.", emberCommandTablePluginDeviceTableIremoveCommandArguments),
	emberCommandEntryActionWithDetails("irepair", emAfDeviceTableIndexRouteRepairCommand, "v", "Kick off device route repair.", emberCommandTablePluginDeviceTableIrepairCommandArguments),
	emberCommandEntryActionWithDetails("isend", emAfDeviceTableIndexSendCommand, "v", "Send to device in device table.", emberCommandTablePluginDeviceTableIsendCommandArguments),
	emberCommandEntryActionWithDetails("leave", emAfPluginDeviceTableSendLeaveCommand, "b", "Remove device from device table.", emberCommandTablePluginDeviceTableLeaveCommandArguments),
	emberCommandEntryActionWithDetails("load", emAfDeviceTableLoadCommand, "", "Load the file.", NULL),
	emberCommandEntryActionWithDetails("print", emberAfDeviceTablePrintDeviceTable, "", "Print the device table.", NULL),
	emberCommandEntryActionWithDetails("remove", emAfDeviceTableRemoveCommand, "b", "Remove device from device table.", emberCommandTablePluginDeviceTableRemoveCommandArguments),
	emberCommandEntryActionWithDetails("repair", emAfDeviceTableRouteRepairCommand, "b", "Kick off device route repair.", emberCommandTablePluginDeviceTableRepairCommandArguments),
	emberCommandEntryActionWithDetails("save", emAfDeviceTableSaveCommand, "", "Save the file.", NULL),
	emberCommandEntryActionWithDetails("send", emAfDeviceTableSendCommand, "bu", "Send to device in device table.", emberCommandTablePluginDeviceTableSendCommandArguments),
	emberCommandEntryTerminator()
};

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM emberCommandTablePluginCommandRelayAddCommandArguments[] = {
  "Incoming device EUI64.",
  "Incoming device endpoint.",
  "Incoming cluster ID.",
  "Outgoing device EUI64.",
  "Outgoing device endpoint.",
  "Outgoing cluster ID.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM emberCommandTablePluginCommandRelayRemoveCommandArguments[] = {
  "Incoming device EUI64.",
  "Incoming device endpoint.",
  "Incoming cluster ID.",
  "Outgoing device EUI64.",
  "Outgoing device endpoint.",
  "Outgoing cluster ID.",
  NULL
};
#endif

static EmberCommandEntry emberCommandTablePluginCommandRelayCommands[] = {
	emberCommandEntryActionWithDetails("add", emAfPluginCommandRelayAddCommand, "buvbuv", "Retransmit commands from inDevice to outDevice.", emberCommandTablePluginCommandRelayAddCommandArguments),
	emberCommandEntryActionWithDetails("clear", emAfPluginCommandRelayClearCommand, "", "Clear all relays.", NULL),
	emberCommandEntryActionWithDetails("load", emAfPluginCommandRelayLoadCommand, "", "Load from disk.", NULL),
	emberCommandEntryActionWithDetails("print", emAfPluginCommandRelayPrintCommand, "", "Print relays.", NULL),
	emberCommandEntryActionWithDetails("remove", emAfPluginCommandRelayRemoveCommand, "buvbuv", "Deletes a relay between devices.", emberCommandTablePluginCommandRelayRemoveCommandArguments),
	emberCommandEntryActionWithDetails("save", emAfPluginCommandRelaySaveCommand, "", "Save to disk.", NULL),
	emberCommandEntryTerminator()
};

static EmberCommandEntry emberCommandTablePluginButtonJoiningCommands[] = {
  emberCommandEntryActionWithDetails("button0", emberAfPluginButtonJoiningButton0Command, "", "Simulate a depression of button 0.", NULL),
  emberCommandEntryActionWithDetails("button1", emberAfPluginButtonJoiningButton1Command, "", "Simulate a depression of button 1.", NULL),
  emberCommandEntryTerminator()
};

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

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

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

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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("button-joining", emberCommandTablePluginButtonJoiningCommands, ""),
	emberCommandEntrySubMenu("command-relay", emberCommandTablePluginCommandRelayCommands, ""),
	emberCommandEntrySubMenu("concentrator", emberCommandTablePluginConcentratorCommands, ""),
	emberCommandEntrySubMenu("counter", emberCommandTablePluginCounterCommands, ""),
	emberCommandEntrySubMenu("counters", emberCommandTablePluginCountersCommands, ""),
	emberCommandEntrySubMenu("device-table", emberCommandTablePluginDeviceTableCommands, ""),
  emberCommandEntrySubMenu("ezmode-commissioning", emberCommandTablePluginEzmodeCommissioningCommands, ""),
	emberCommandEntrySubMenu("gateway", emberCommandTablePluginGatewayCommands, ""),
  emberCommandEntrySubMenu("green-power-client", emberCommandTablePluginGreenPowerClientCommands, ""),
	emberCommandEntrySubMenu("ias-zone-client", emberCommandTablePluginIasZoneClientCommands, ""),
	emberCommandEntrySubMenu("identify", emberCommandTablePluginIdentifyCommands, ""),
	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 PGM_P PGM emberCommandTableOptionSecuritySetAllowTrustCenterRejoinUsingWellKnownKeyCommandArguments[] = {
  "Whether or not the Trust Center should allow trust center rejoins for  ...",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM emberCommandTableOptionSecuritySetAllowTrustCenterRejoinUsingWellKnownKeyTimeoutCommandArguments[] = {
  "The number of seconds that trust center rejoins will be responded to u ...",
  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),
  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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM emberCommandTableNetworkChangeChannelCommandArguments[] = {
  "The channel to change to.",
  NULL
};
#endif

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

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM emberCommandTableInterpanGroupCommandArguments[] = {
  "group id to send to",
  "destination pan id",
  "destination profile ID",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM emberCommandTableEndpointDisableCommandArguments[] = {
  "Endpoint in question.",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM emberCommandTableDebugprintOffCommandArguments[] = {
	"The debug area mask listed in the <application>.h file",
	NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM emberCommandTableChangekeyLinkCommandArguments[] = {
  "The link key provided as a 16 byte array",
  NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM emberCommandTableBsendCommandArguments[] = {
	"Source endpoint to send a binding based message from",
	NULL
};
#endif

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

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

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM emberCommandTableSendUsingMulticastBindingCommandArguments[] = {
	"Whether to send via a multicast binding",
	NULL
};
#endif

#if defined(EMBER_COMMAND_INTEPRETER_HAS_DESCRIPTION_FIELD)
static PGM_P PGM 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 PGM_P PGM 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 PGM_P PGM 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()
};



