health.pb.h

Go to the documentation of this file.

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: jaiabot/messages/health.proto
 
#ifndef PROTOBUF_INCLUDED_jaiabot_2fmessages_2fhealth_2eproto
#define PROTOBUF_INCLUDED_jaiabot_2fmessages_2fhealth_2eproto
 
#include <string>
 
#include <google/protobuf/stubs/common.h>
 
#if GOOGLE_PROTOBUF_VERSION < 3006001
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please update
#error your headers.
#endif
#if 3006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif
 
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "dccl/option_extensions.pb.h"
#include "goby/middleware/protobuf/coroner.pb.h"
#include "jaiabot/messages/option_extensions.pb.h"
#include <boost/units/quantity.hpp>
#include <boost/units/absolute.hpp>
#include <boost/units/dimensionless_type.hpp>
#include <boost/units/make_scaled_unit.hpp>
 
#include <boost/units/systems/si.hpp>
 
#include <boost/units/base_units/information/byte.hpp>
// @@protoc_insertion_point(includes)
#define PROTOBUF_INTERNAL_EXPORT_protobuf_jaiabot_2fmessages_2fhealth_2eproto 
 
namespace protobuf_jaiabot_2fmessages_2fhealth_2eproto {
// Internal implementation detail -- do not use these members.
struct TableStruct {
  static const ::google::protobuf::internal::ParseTableField entries[];
  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
  static const ::google::protobuf::internal::ParseTable schema[15];
  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
  static const ::google::protobuf::internal::SerializationTable serialization_table[];
  static const ::google::protobuf::uint32 offsets[];
};
void AddDescriptors();
}  // namespace protobuf_jaiabot_2fmessages_2fhealth_2eproto
namespace jaiabot {
namespace protobuf {
class HelmIVPStatus;
class HelmIVPStatusDefaultTypeInternal;
extern HelmIVPStatusDefaultTypeInternal _HelmIVPStatus_default_instance_;
class LinuxHardwareStatus;
class LinuxHardwareStatusDefaultTypeInternal;
extern LinuxHardwareStatusDefaultTypeInternal _LinuxHardwareStatus_default_instance_;
class LinuxHardwareStatus_Disk;
class LinuxHardwareStatus_DiskDefaultTypeInternal;
extern LinuxHardwareStatus_DiskDefaultTypeInternal _LinuxHardwareStatus_Disk_default_instance_;
class LinuxHardwareStatus_Information;
class LinuxHardwareStatus_InformationDefaultTypeInternal;
extern LinuxHardwareStatus_InformationDefaultTypeInternal _LinuxHardwareStatus_Information_default_instance_;
class LinuxHardwareStatus_Memory;
class LinuxHardwareStatus_MemoryDefaultTypeInternal;
extern LinuxHardwareStatus_MemoryDefaultTypeInternal _LinuxHardwareStatus_Memory_default_instance_;
class LinuxHardwareStatus_Processor;
class LinuxHardwareStatus_ProcessorDefaultTypeInternal;
extern LinuxHardwareStatus_ProcessorDefaultTypeInternal _LinuxHardwareStatus_Processor_default_instance_;
class LinuxHardwareStatus_Processor_LoadAverages;
class LinuxHardwareStatus_Processor_LoadAveragesDefaultTypeInternal;
extern LinuxHardwareStatus_Processor_LoadAveragesDefaultTypeInternal _LinuxHardwareStatus_Processor_LoadAverages_default_instance_;
class LinuxHardwareStatus_WiFi;
class LinuxHardwareStatus_WiFiDefaultTypeInternal;
extern LinuxHardwareStatus_WiFiDefaultTypeInternal _LinuxHardwareStatus_WiFi_default_instance_;
class NTPStatus;
class NTPStatusDefaultTypeInternal;
extern NTPStatusDefaultTypeInternal _NTPStatus_default_instance_;
class NTPStatus_NTPPeer;
class NTPStatus_NTPPeerDefaultTypeInternal;
extern NTPStatus_NTPPeerDefaultTypeInternal _NTPStatus_NTPPeer_default_instance_;
class SystemdReportAck;
class SystemdReportAckDefaultTypeInternal;
extern SystemdReportAckDefaultTypeInternal _SystemdReportAck_default_instance_;
class SystemdStartReport;
class SystemdStartReportDefaultTypeInternal;
extern SystemdStartReportDefaultTypeInternal _SystemdStartReport_default_instance_;
class SystemdStopReport;
class SystemdStopReportDefaultTypeInternal;
extern SystemdStopReportDefaultTypeInternal _SystemdStopReport_default_instance_;
class ThreadHealth;
class ThreadHealthDefaultTypeInternal;
extern ThreadHealthDefaultTypeInternal _ThreadHealth_default_instance_;
class VehicleHealth;
class VehicleHealthDefaultTypeInternal;
extern VehicleHealthDefaultTypeInternal _VehicleHealth_default_instance_;
}  // namespace protobuf
}  // namespace jaiabot
namespace google {
namespace protobuf {
template<> ::jaiabot::protobuf::HelmIVPStatus* Arena::CreateMaybeMessage<::jaiabot::protobuf::HelmIVPStatus>(Arena*);
template<> ::jaiabot::protobuf::LinuxHardwareStatus* Arena::CreateMaybeMessage<::jaiabot::protobuf::LinuxHardwareStatus>(Arena*);
template<> ::jaiabot::protobuf::LinuxHardwareStatus_Disk* Arena::CreateMaybeMessage<::jaiabot::protobuf::LinuxHardwareStatus_Disk>(Arena*);
template<> ::jaiabot::protobuf::LinuxHardwareStatus_Information* Arena::CreateMaybeMessage<::jaiabot::protobuf::LinuxHardwareStatus_Information>(Arena*);
template<> ::jaiabot::protobuf::LinuxHardwareStatus_Memory* Arena::CreateMaybeMessage<::jaiabot::protobuf::LinuxHardwareStatus_Memory>(Arena*);
template<> ::jaiabot::protobuf::LinuxHardwareStatus_Processor* Arena::CreateMaybeMessage<::jaiabot::protobuf::LinuxHardwareStatus_Processor>(Arena*);
template<> ::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages* Arena::CreateMaybeMessage<::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages>(Arena*);
template<> ::jaiabot::protobuf::LinuxHardwareStatus_WiFi* Arena::CreateMaybeMessage<::jaiabot::protobuf::LinuxHardwareStatus_WiFi>(Arena*);
template<> ::jaiabot::protobuf::NTPStatus* Arena::CreateMaybeMessage<::jaiabot::protobuf::NTPStatus>(Arena*);
template<> ::jaiabot::protobuf::NTPStatus_NTPPeer* Arena::CreateMaybeMessage<::jaiabot::protobuf::NTPStatus_NTPPeer>(Arena*);
template<> ::jaiabot::protobuf::SystemdReportAck* Arena::CreateMaybeMessage<::jaiabot::protobuf::SystemdReportAck>(Arena*);
template<> ::jaiabot::protobuf::SystemdStartReport* Arena::CreateMaybeMessage<::jaiabot::protobuf::SystemdStartReport>(Arena*);
template<> ::jaiabot::protobuf::SystemdStopReport* Arena::CreateMaybeMessage<::jaiabot::protobuf::SystemdStopReport>(Arena*);
template<> ::jaiabot::protobuf::ThreadHealth* Arena::CreateMaybeMessage<::jaiabot::protobuf::ThreadHealth>(Arena*);
template<> ::jaiabot::protobuf::VehicleHealth* Arena::CreateMaybeMessage<::jaiabot::protobuf::VehicleHealth>(Arena*);
}  // namespace protobuf
}  // namespace google
namespace jaiabot {
namespace protobuf {
 
enum NTPStatus_NTPPeer_TallyCode {
  NTPStatus_NTPPeer_TallyCode_PEER_CODE_UNKNOWN = -1,
  NTPStatus_NTPPeer_TallyCode_PEER_NOT_VALID = 32,
  NTPStatus_NTPPeer_TallyCode_PEER_DISCARDED_BY_INTERSECTION = 120,
  NTPStatus_NTPPeer_TallyCode_PEER_DISCARDED_BY_TABLE_OVERFLOW = 46,
  NTPStatus_NTPPeer_TallyCode_PEER_DISCARDED_BY_CLUSTER_ALGORITHM = 45,
  NTPStatus_NTPPeer_TallyCode_PEER_INCLUDED_IN_COMBINE = 43,
  NTPStatus_NTPPeer_TallyCode_PEER_ALTERNATIVE_BACKUP = 35,
  NTPStatus_NTPPeer_TallyCode_PEER_SYSTEM_SYNC_SOURCE = 42,
  NTPStatus_NTPPeer_TallyCode_PEER_PPS_SYNC = 111
};
bool NTPStatus_NTPPeer_TallyCode_IsValid(int value);
const NTPStatus_NTPPeer_TallyCode NTPStatus_NTPPeer_TallyCode_TallyCode_MIN = NTPStatus_NTPPeer_TallyCode_PEER_CODE_UNKNOWN;
const NTPStatus_NTPPeer_TallyCode NTPStatus_NTPPeer_TallyCode_TallyCode_MAX = NTPStatus_NTPPeer_TallyCode_PEER_DISCARDED_BY_INTERSECTION;
const int NTPStatus_NTPPeer_TallyCode_TallyCode_ARRAYSIZE = NTPStatus_NTPPeer_TallyCode_TallyCode_MAX + 1;
 
const ::google::protobuf::EnumDescriptor* NTPStatus_NTPPeer_TallyCode_descriptor();
inline const ::std::string& NTPStatus_NTPPeer_TallyCode_Name(NTPStatus_NTPPeer_TallyCode value) {
  return ::google::protobuf::internal::NameOfEnum(
    NTPStatus_NTPPeer_TallyCode_descriptor(), value);
}
inline bool NTPStatus_NTPPeer_TallyCode_Parse(
    const ::std::string& name, NTPStatus_NTPPeer_TallyCode* value) {
  return ::google::protobuf::internal::ParseNamedEnum<NTPStatus_NTPPeer_TallyCode>(
    NTPStatus_NTPPeer_TallyCode_descriptor(), name, value);
}
enum NTPStatus_SyncSource {
  NTPStatus_SyncSource_SYNC_UNKNOWN = -1,
  NTPStatus_SyncSource_SYNC_UNSPECIFIED = 0,
  NTPStatus_SyncSource_SYNC_PPS = 1,
  NTPStatus_SyncSource_SYNC_LF_RADIO = 2,
  NTPStatus_SyncSource_SYNC_HF_RADIO = 3,
  NTPStatus_SyncSource_SYNC_UHF_RADIO = 4,
  NTPStatus_SyncSource_SYNC_LOCAL = 5,
  NTPStatus_SyncSource_SYNC_NTP = 6,
  NTPStatus_SyncSource_SYNC_OTHER = 7,
  NTPStatus_SyncSource_SYNC_WRISTWATCH = 8,
  NTPStatus_SyncSource_SYNC_TELEPHONE = 9
};
bool NTPStatus_SyncSource_IsValid(int value);
const NTPStatus_SyncSource NTPStatus_SyncSource_SyncSource_MIN = NTPStatus_SyncSource_SYNC_UNKNOWN;
const NTPStatus_SyncSource NTPStatus_SyncSource_SyncSource_MAX = NTPStatus_SyncSource_SYNC_TELEPHONE;
const int NTPStatus_SyncSource_SyncSource_ARRAYSIZE = NTPStatus_SyncSource_SyncSource_MAX + 1;
 
const ::google::protobuf::EnumDescriptor* NTPStatus_SyncSource_descriptor();
inline const ::std::string& NTPStatus_SyncSource_Name(NTPStatus_SyncSource value) {
  return ::google::protobuf::internal::NameOfEnum(
    NTPStatus_SyncSource_descriptor(), value);
}
inline bool NTPStatus_SyncSource_Parse(
    const ::std::string& name, NTPStatus_SyncSource* value) {
  return ::google::protobuf::internal::ParseNamedEnum<NTPStatus_SyncSource>(
    NTPStatus_SyncSource_descriptor(), name, value);
}
enum NTPStatus_LeapIndicator {
  NTPStatus_LeapIndicator_LEAP_UNKNOWN = -1,
  NTPStatus_LeapIndicator_LEAP_NONE = 0,
  NTPStatus_LeapIndicator_LEAP_LAST_MINUTE_HAS_61_SECONDS = 1,
  NTPStatus_LeapIndicator_LEAP_LAST_MINUTE_HAS_59_SECONDS = 2,
  NTPStatus_LeapIndicator_LEAP_CLOCK_NOT_SYNCHRONIZED = 3
};
bool NTPStatus_LeapIndicator_IsValid(int value);
const NTPStatus_LeapIndicator NTPStatus_LeapIndicator_LeapIndicator_MIN = NTPStatus_LeapIndicator_LEAP_UNKNOWN;
const NTPStatus_LeapIndicator NTPStatus_LeapIndicator_LeapIndicator_MAX = NTPStatus_LeapIndicator_LEAP_CLOCK_NOT_SYNCHRONIZED;
const int NTPStatus_LeapIndicator_LeapIndicator_ARRAYSIZE = NTPStatus_LeapIndicator_LeapIndicator_MAX + 1;
 
const ::google::protobuf::EnumDescriptor* NTPStatus_LeapIndicator_descriptor();
inline const ::std::string& NTPStatus_LeapIndicator_Name(NTPStatus_LeapIndicator value) {
  return ::google::protobuf::internal::NameOfEnum(
    NTPStatus_LeapIndicator_descriptor(), value);
}
inline bool NTPStatus_LeapIndicator_Parse(
    const ::std::string& name, NTPStatus_LeapIndicator* value) {
  return ::google::protobuf::internal::ParseNamedEnum<NTPStatus_LeapIndicator>(
    NTPStatus_LeapIndicator_descriptor(), name, value);
}
enum NTPStatus_NTPSystemEvent {
  NTPStatus_NTPSystemEvent_NTP_SYSTEM_EVENT_UNKNOWN = -1,
  NTPStatus_NTPSystemEvent_NTP_SYSTEM_EVENT_UNSPECIFIED = 0,
  NTPStatus_NTPSystemEvent_NTP_SYSTEM_FREQ_NOT_SET = 1,
  NTPStatus_NTPSystemEvent_NTP_SYSTEM_FREQ_SET = 2,
  NTPStatus_NTPSystemEvent_NTP_SYSTEM_SPIKE_DETECT = 3,
  NTPStatus_NTPSystemEvent_NTP_SYSTEM_FREQ_MODE = 4,
  NTPStatus_NTPSystemEvent_NTP_SYSTEM_CLOCK_SYNC = 5,
  NTPStatus_NTPSystemEvent_NTP_SYSTEM_RESTART = 6,
  NTPStatus_NTPSystemEvent_NTP_SYSTEM_PANIC_STOP = 7,
  NTPStatus_NTPSystemEvent_NTP_SYSTEM_NO_SYSTEM_PEER = 8,
  NTPStatus_NTPSystemEvent_NTP_SYSTEM_LEAP_ARMED = 9,
  NTPStatus_NTPSystemEvent_NTP_SYSTEM_LEAP_DISARMED = 10,
  NTPStatus_NTPSystemEvent_NTP_SYSTEM_LEAP_EVENT = 11,
  NTPStatus_NTPSystemEvent_NTP_SYSTEM_CLOCK_STEP = 12,
  NTPStatus_NTPSystemEvent_NTP_SYSTEM_KERNEL_INFO = 13,
  NTPStatus_NTPSystemEvent_NTP_SYSTEM_LEAPSECOND_VALUES_UPDATE_FROM_FILE = 14,
  NTPStatus_NTPSystemEvent_NTP_SYSTEM_STALE_LEAPSECOND_VALUES = 15
};
bool NTPStatus_NTPSystemEvent_IsValid(int value);
const NTPStatus_NTPSystemEvent NTPStatus_NTPSystemEvent_NTPSystemEvent_MIN = NTPStatus_NTPSystemEvent_NTP_SYSTEM_EVENT_UNKNOWN;
const NTPStatus_NTPSystemEvent NTPStatus_NTPSystemEvent_NTPSystemEvent_MAX = NTPStatus_NTPSystemEvent_NTP_SYSTEM_STALE_LEAPSECOND_VALUES;
const int NTPStatus_NTPSystemEvent_NTPSystemEvent_ARRAYSIZE = NTPStatus_NTPSystemEvent_NTPSystemEvent_MAX + 1;
 
const ::google::protobuf::EnumDescriptor* NTPStatus_NTPSystemEvent_descriptor();
inline const ::std::string& NTPStatus_NTPSystemEvent_Name(NTPStatus_NTPSystemEvent value) {
  return ::google::protobuf::internal::NameOfEnum(
    NTPStatus_NTPSystemEvent_descriptor(), value);
}
inline bool NTPStatus_NTPSystemEvent_Parse(
    const ::std::string& name, NTPStatus_NTPSystemEvent* value) {
  return ::google::protobuf::internal::ParseNamedEnum<NTPStatus_NTPSystemEvent>(
    NTPStatus_NTPSystemEvent_descriptor(), name, value);
}
enum SystemdStopReport_ServiceResult {
  SystemdStopReport_ServiceResult_SERVICE_RESULT_UNKNOWN = 0,
  SystemdStopReport_ServiceResult_SERVICE_RESULT_SUCCESS = 1,
  SystemdStopReport_ServiceResult_SERVICE_RESULT_PROTOCOL = 2,
  SystemdStopReport_ServiceResult_SERVICE_RESULT_TIMEOUT = 3,
  SystemdStopReport_ServiceResult_SERVICE_RESULT_EXIT_CODE = 4,
  SystemdStopReport_ServiceResult_SERVICE_RESULT_SIGNAL = 5,
  SystemdStopReport_ServiceResult_SERVICE_RESULT_CORE_DUMP = 6,
  SystemdStopReport_ServiceResult_SERVICE_RESULT_WATCHDOG = 7,
  SystemdStopReport_ServiceResult_SERVICE_RESULT_START_LIMIT_HIT = 8,
  SystemdStopReport_ServiceResult_SERVICE_RESULT_RESOURCES = 9
};
bool SystemdStopReport_ServiceResult_IsValid(int value);
const SystemdStopReport_ServiceResult SystemdStopReport_ServiceResult_ServiceResult_MIN = SystemdStopReport_ServiceResult_SERVICE_RESULT_UNKNOWN;
const SystemdStopReport_ServiceResult SystemdStopReport_ServiceResult_ServiceResult_MAX = SystemdStopReport_ServiceResult_SERVICE_RESULT_RESOURCES;
const int SystemdStopReport_ServiceResult_ServiceResult_ARRAYSIZE = SystemdStopReport_ServiceResult_ServiceResult_MAX + 1;
 
const ::google::protobuf::EnumDescriptor* SystemdStopReport_ServiceResult_descriptor();
inline const ::std::string& SystemdStopReport_ServiceResult_Name(SystemdStopReport_ServiceResult value) {
  return ::google::protobuf::internal::NameOfEnum(
    SystemdStopReport_ServiceResult_descriptor(), value);
}
inline bool SystemdStopReport_ServiceResult_Parse(
    const ::std::string& name, SystemdStopReport_ServiceResult* value) {
  return ::google::protobuf::internal::ParseNamedEnum<SystemdStopReport_ServiceResult>(
    SystemdStopReport_ServiceResult_descriptor(), name, value);
}
enum Error {
  ERROR__TOO_MANY_ERRORS_TO_REPORT_ALL = 0,
  ERROR__FAILED__UNKNOWN = 1,
  ERROR__FAILED__GOBYD = 2,
  ERROR__FAILED__GOBY_LIAISON = 3,
  ERROR__FAILED__GOBY_GPS = 4,
  ERROR__FAILED__GOBY_LOGGER = 5,
  ERROR__FAILED__GOBY_CORONER = 6,
  ERROR__FAILED__GOBY_MOOS_GATEWAY = 7,
  ERROR__FAILED__JAIABOT_HEALTH = 8,
  ERROR__FAILED__JAIABOT_METADATA = 9,
  ERROR__FAILED__JAIABOT_HUB_MANAGER = 10,
  ERROR__FAILED__JAIABOT_WEB_PORTAL = 11,
  ERROR__FAILED__JAIABOT_FUSION = 12,
  ERROR__FAILED__JAIABOT_MISSION_MANAGER = 13,
  ERROR__FAILED__JAIABOT_PID_CONTROL = 14,
  ERROR__FAILED__JAIABOT_BLUEROBOTICS_PRESSURE_SENSOR_DRIVER = 15,
  ERROR__FAILED__JAIABOT_ATLAS_SCIENTIFIC_EZO_EC_DRIVER = 16,
  ERROR__FAILED__JAIABOT_ADAFRUIT_BNO055_DRIVER = 17,
  ERROR__FAILED__JAIABOT_DRIVER_ARDUINO = 18,
  ERROR__FAILED__JAIABOT_ENGINEERING = 19,
  ERROR__FAILED__MOOS_MOOSDB = 20,
  ERROR__FAILED__MOOS_PHELMIVP = 21,
  ERROR__FAILED__MOOS_UPROCESSWATCH = 22,
  ERROR__FAILED__MOOS_PNODEREPORTER = 23,
  ERROR__FAILED__PYTHON_JAIABOT_WEB_APP = 24,
  ERROR__FAILED__PYTHON_JAIABOT_IMU = 25,
  ERROR__FAILED__PYTHON_JAIABOT_PRESSURE_SENSOR = 26,
  ERROR__FAILED__PYTHON_JAIABOT_AS_EZO_EC = 27,
  ERROR__FAILED__JAIABOT_LOG_CONVERTER = 28,
  ERROR__FAILED__JAIABOT_DATA_VISION = 29,
  ERROR__FAILED__JAIABOT_SIMULATOR = 30,
  ERROR__FAILED__MOOS_SIM_MOOSDB = 31,
  ERROR__FAILED__MOOS_SIM_USIMMARINE = 32,
  ERROR__FAILED__GOBY_INTERVEHICLE_PORTAL = 33,
  ERROR__FAILED__JAIABOT_ADAFRUIT_BNO085_DRIVER = 34,
  ERROR__FAILED__JAIABOT_ECHO_DRIVER = 35,
  ERROR__FAILED__PYTHON_JAIABOT_ECHO = 36,
  ERROR__FAILED__JAIABOT_TSYS01_TEMPERATURE_SENSOR_DRIVER = 37,
  ERROR__FAILED__PYTHON_JAIABOT_TSYS01_TEMPERATURE_SENSOR_DRIVER = 38,
  ERROR__FAILED__PYTHON_JAIABOT_MOTOR_LISTENER = 39,
  ERROR__NOT_RESPONDING__UNKNOWN_APP = 100,
  ERROR__NOT_RESPONDING__GOBYD = 101,
  ERROR__NOT_RESPONDING__GOBY_LIAISON = 102,
  ERROR__NOT_RESPONDING__GOBY_GPS = 103,
  ERROR__NOT_RESPONDING__GOBY_LOGGER = 104,
  ERROR__NOT_RESPONDING__GOBY_CORONER = 105,
  ERROR__NOT_RESPONDING__JAIABOT_HEALTH = 106,
  ERROR__NOT_RESPONDING__JAIABOT_METADATA = 107,
  ERROR__NOT_RESPONDING__JAIABOT_HUB_MANAGER = 108,
  ERROR__NOT_RESPONDING__JAIABOT_WEB_PORTAL = 109,
  ERROR__NOT_RESPONDING__JAIABOT_FUSION = 110,
  ERROR__NOT_RESPONDING__GOBY_MOOS_GATEWAY = 111,
  ERROR__NOT_RESPONDING__JAIABOT_MISSION_MANAGER = 112,
  ERROR__NOT_RESPONDING__JAIABOT_PID_CONTROL = 113,
  ERROR__NOT_RESPONDING__JAIABOT_BLUEROBOTICS_PRESSURE_SENSOR_DRIVER = 114,
  ERROR__NOT_RESPONDING__JAIABOT_ATLAS_SCIENTIFIC_EZO_EC_DRIVER = 115,
  ERROR__NOT_RESPONDING__JAIABOT_ADAFRUIT_BNO055_DRIVER = 116,
  ERROR__NOT_RESPONDING__JAIABOT_DRIVER_ARDUINO = 117,
  ERROR__NOT_RESPONDING__JAIABOT_ENGINEERING = 118,
  ERROR__NOT_RESPONDING__JAIABOT_SINGLE_THREAD_PATTERN = 119,
  ERROR__NOT_RESPONDING__JAIABOT_MULTI_THREAD_PATTERN = 120,
  ERROR__NOT_RESPONDING__JAIABOT_SIMULATOR = 121,
  ERROR__NOT_RESPONDING__GOBY_INTERVEHICLE_PORTAL = 122,
  ERROR__NOT_RESPONDING__JAIABOT_ADAFRUIT_BNO085_DRIVER = 123,
  ERROR__NOT_RESPONDING__JAIABOT_ECHO_DRIVER = 124,
  ERROR__NOT_RESPONDING__JAIABOT_TSYS01_TEMPERATURE_SENSOR_DRIVER = 125,
  ERROR__MISSING_DATA__GPS_FIX = 200,
  ERROR__MISSING_DATA__GPS_POSITION = 201,
  ERROR__MISSING_DATA__PRESSURE = 210,
  ERROR__MISSING_DATA__HEADING = 212,
  ERROR__MISSING_DATA__SPEED = 215,
  ERROR__MISSING_DATA__COURSE = 216,
  ERROR__MISSING_DATA__CALIBRATION_SYS = 217,
  ERROR__MISSING_DATA__CALIBRATION_GYRO = 218,
  ERROR__MISSING_DATA__CALIBRATION_ACCEL = 219,
  ERROR__MISSING_DATA__CALIBRATION_MAG = 220,
  ERROR__NOT_CALIBRATED_SYS = 221,
  ERROR__NOT_CALIBRATED_GYRO = 222,
  ERROR__NOT_CALIBRATED_ACCEL = 223,
  ERROR__NOT_CALIBRATED_MAG = 224,
  ERROR__NOT_CALIBRATED_IMU = 225,
  ERROR__COMMS__NO_XBEE = 300,
  ERROR__MOOS__HELMIVP_STATE_NOT_DRIVE = 400,
  ERROR__MOOS__HELMIVP_NO_DESIRED_DATA = 401,
  ERROR__MOOS__NO_DATA = 402,
  ERROR__SYSTEM__CANNOT_READ_MEMINFO = 500,
  ERROR__SYSTEM__RAM_SPACE_CRITICAL = 501,
  ERROR__SYSTEM__CANNOT_READ_SYSINFO = 502,
  ERROR__SYSTEM__CPU_LOAD_FACTOR_CRITICAL = 503,
  ERROR__SYSTEM__CANNOT_READ_DISK_USAGE = 504,
  ERROR__SYSTEM__ROOTFS_DISK_SPACE_CRITICAL = 505,
  ERROR__SYSTEM__DATA_DISK_SPACE_CRITICAL = 506,
  ERROR__SYSTEM__NTP_PEERS_QUERY_FAILED = 510,
  ERROR__SYSTEM__NTP_STATUS_QUERY_FAILED = 511,
  ERROR__VEHICLE__VERY_LOW_BATTERY = 600,
  ERROR__VEHICLE__CRITICALLY_LOW_BATTERY = 601,
  ERROR__VEHICLE__MISSING_DATA_BATTERY = 602,
  ERROR__VERSION__MISMATCH_ARDUINO = 700,
  ERROR__MISSING_DATA__ARDUINO_REPORT = 701,
  ERROR__VERSION__MISMATCH_INTERVEHICLE__UPGRADE_HUB = 702,
  ERROR__VERSION__MISMATCH_INTERVEHICLE__UPGRADE_BOT = 703,
  ERROR__ARDUINO_CONNECTION_FAILED = 704
};
bool Error_IsValid(int value);
const Error Error_MIN = ERROR__TOO_MANY_ERRORS_TO_REPORT_ALL;
const Error Error_MAX = ERROR__ARDUINO_CONNECTION_FAILED;
const int Error_ARRAYSIZE = Error_MAX + 1;
 
const ::google::protobuf::EnumDescriptor* Error_descriptor();
inline const ::std::string& Error_Name(Error value) {
  return ::google::protobuf::internal::NameOfEnum(
    Error_descriptor(), value);
}
inline bool Error_Parse(
    const ::std::string& name, Error* value) {
  return ::google::protobuf::internal::ParseNamedEnum<Error>(
    Error_descriptor(), name, value);
}
enum Warning {
  WARNING__TOO_MANY_WARNINGS_TO_REPORT_ALL = 0,
  WARNING__NOT_RESPONDING__UNKNOWN_APP = 100,
  WARNING__NOT_RESPONDING__JAIABOT_ATLAS_SCIENTIFIC_EZO_EC_DRIVER = 101,
  WARNING__NOT_RESPONDING__JAIABOT_BLUEROBOTICS_PRESSURE_SENSOR_DRIVER = 102,
  WARNING__NOT_RESPONDING__JAIABOT_ADAFRUIT_BNO055_DRIVER = 103,
  WARNING__NOT_RESPONDING__JAIABOT_ADAFRUIT_BNO085_DRIVER = 104,
  WARNING__NOT_RESPONDING__JAIABOT_ECHO_DRIVER = 105,
  WARNING__NOT_RESPONDING__JAIABOT_TSYS01_TEMPERATURE_SENSOR_DRIVER = 106,
  WARNING__MISSING_DATA__PITCH = 200,
  WARNING__MISSING_DATA__ROLL = 201,
  WARNING__MISSING_DATA__TEMPERATURE = 202,
  WARNING__MISSING_DATA__COURSE = 216,
  WARNING__NOT_CALIBRATED_SYS = 221,
  WARNING__IMU_ISSUE = 222,
  WARNING__TEMPERATURE__ARDUINO_TOO_HIGH = 210,
  WARNING__TEMPERATURE__LINUX_TOO_HIGH = 211,
  WARNING__COMMS_LOW_SIGNAL_STRENGTH = 300,
  WARNING__VEHICLE__LOW_BATTERY = 400,
  WARNING__SYSTEM__NTP_NOT_SYNCHRONIZED = 500,
  WARNING__SYSTEM__NTP_OFFSET_HIGH = 501,
  WARNING__SYSTEM__NTP_JITTER_HIGH = 502,
  WARNING__SYSTEM__RAM_SPACE_LOW = 503,
  WARNING__SYSTEM__CPU_LOAD_FACTOR_HIGH = 504,
  WARNING__SYSTEM__ROOTFS_DISK_SPACE_LOW = 505,
  WARNING__SYSTEM__DATA_DISK_SPACE_LOW = 506,
  WARNING__NOT_RESPONDING__JAIABOT_RPM_LISTENER = 600,
  WARNING__NOT_RESPONDING__JAIABOT_ARDUINO_MOTOR_TEMP = 601,
  WARNING__MISSION__INFEASIBLE_MISSION__TRANSIT_MUST_HAVE_A_GOAL = 700,
  WARNING__MISSION__INFEASIBLE_MISSION__TRANSIT_CANNOT_RECOVER_AT_FINAL_GOAL_WITHOUT_A_GOAL = 701,
  WARNING__MISSION__INFEASIBLE_MISSION__MUST_HAVE_RECOVERY_LOCATION_IF_NOT_RECOVERING_AT_FINAL_GOAL = 702,
  WARNING__MISSION__INFEASIBLE_MISSION__MINIMUM_BOTTOM_DEPTH_REACHED = 703,
  WARNING__MISSION__INFEASIBLE_MISSION__GOAL_DESIRED_DEPTH_EXCEEDED_MAX = 704,
  WARNING__VEHICLE__NO_FORWARD_PROGRESS = 705,
  WARNING__MISSION__DATA_OFFLOAD_FAILED = 720,
  WARNING__MISSION__DATA__GPS_FIX_DEGRADED = 721,
  WARNING__MISSION__DATA_PRE_OFFLOAD_FAILED = 722,
  WARNING__MISSION__DATA_POST_OFFLOAD_FAILED = 723
};
bool Warning_IsValid(int value);
const Warning Warning_MIN = WARNING__TOO_MANY_WARNINGS_TO_REPORT_ALL;
const Warning Warning_MAX = WARNING__MISSION__DATA_POST_OFFLOAD_FAILED;
const int Warning_ARRAYSIZE = Warning_MAX + 1;
 
const ::google::protobuf::EnumDescriptor* Warning_descriptor();
inline const ::std::string& Warning_Name(Warning value) {
  return ::google::protobuf::internal::NameOfEnum(
    Warning_descriptor(), value);
}
inline bool Warning_Parse(
    const ::std::string& name, Warning* value) {
  return ::google::protobuf::internal::ParseNamedEnum<Warning>(
    Warning_descriptor(), name, value);
}
// ===================================================================
 
class LinuxHardwareStatus_Processor_LoadAverages : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:jaiabot.protobuf.LinuxHardwareStatus.Processor.LoadAverages) */ {
 public:
  LinuxHardwareStatus_Processor_LoadAverages();
  virtual ~LinuxHardwareStatus_Processor_LoadAverages();
 
  LinuxHardwareStatus_Processor_LoadAverages(const LinuxHardwareStatus_Processor_LoadAverages& from);
 
  inline LinuxHardwareStatus_Processor_LoadAverages& operator=(const LinuxHardwareStatus_Processor_LoadAverages& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  LinuxHardwareStatus_Processor_LoadAverages(LinuxHardwareStatus_Processor_LoadAverages&& from) noexcept
    : LinuxHardwareStatus_Processor_LoadAverages() {
    *this = ::std::move(from);
  }
 
  inline LinuxHardwareStatus_Processor_LoadAverages& operator=(LinuxHardwareStatus_Processor_LoadAverages&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const LinuxHardwareStatus_Processor_LoadAverages& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const LinuxHardwareStatus_Processor_LoadAverages* internal_default_instance() {
    return reinterpret_cast<const LinuxHardwareStatus_Processor_LoadAverages*>(
               &_LinuxHardwareStatus_Processor_LoadAverages_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;
 
  void Swap(LinuxHardwareStatus_Processor_LoadAverages* other);
  friend void swap(LinuxHardwareStatus_Processor_LoadAverages& a, LinuxHardwareStatus_Processor_LoadAverages& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline LinuxHardwareStatus_Processor_LoadAverages* New() const final {
    return CreateMaybeMessage<LinuxHardwareStatus_Processor_LoadAverages>(NULL);
  }
 
  LinuxHardwareStatus_Processor_LoadAverages* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<LinuxHardwareStatus_Processor_LoadAverages>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const LinuxHardwareStatus_Processor_LoadAverages& from);
  void MergeFrom(const LinuxHardwareStatus_Processor_LoadAverages& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LinuxHardwareStatus_Processor_LoadAverages* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // required float one_min = 1;
  bool has_one_min() const;
  void clear_one_min();
  static const int kOneMinFieldNumber = 1;
  float one_min() const;
  void set_one_min(float value);
 
  // required float five_min = 2;
  bool has_five_min() const;
  void clear_five_min();
  static const int kFiveMinFieldNumber = 2;
  float five_min() const;
  void set_five_min(float value);
 
  // required float fifteen_min = 3;
  bool has_fifteen_min() const;
  void clear_fifteen_min();
  static const int kFifteenMinFieldNumber = 3;
  float fifteen_min() const;
  void set_fifteen_min(float value);
 
  // @@protoc_insertion_point(class_scope:jaiabot.protobuf.LinuxHardwareStatus.Processor.LoadAverages)
 private:
  void set_has_one_min();
  void clear_has_one_min();
  void set_has_five_min();
  void clear_has_five_min();
  void set_has_fifteen_min();
  void clear_has_fifteen_min();
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  float one_min_;
  float five_min_;
  float fifteen_min_;
  friend struct ::protobuf_jaiabot_2fmessages_2fhealth_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class LinuxHardwareStatus_Processor : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:jaiabot.protobuf.LinuxHardwareStatus.Processor) */ {
 public:
  LinuxHardwareStatus_Processor();
  virtual ~LinuxHardwareStatus_Processor();
 
  LinuxHardwareStatus_Processor(const LinuxHardwareStatus_Processor& from);
 
  inline LinuxHardwareStatus_Processor& operator=(const LinuxHardwareStatus_Processor& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  LinuxHardwareStatus_Processor(LinuxHardwareStatus_Processor&& from) noexcept
    : LinuxHardwareStatus_Processor() {
    *this = ::std::move(from);
  }
 
  inline LinuxHardwareStatus_Processor& operator=(LinuxHardwareStatus_Processor&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const LinuxHardwareStatus_Processor& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const LinuxHardwareStatus_Processor* internal_default_instance() {
    return reinterpret_cast<const LinuxHardwareStatus_Processor*>(
               &_LinuxHardwareStatus_Processor_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;
 
  void Swap(LinuxHardwareStatus_Processor* other);
  friend void swap(LinuxHardwareStatus_Processor& a, LinuxHardwareStatus_Processor& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline LinuxHardwareStatus_Processor* New() const final {
    return CreateMaybeMessage<LinuxHardwareStatus_Processor>(NULL);
  }
 
  LinuxHardwareStatus_Processor* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<LinuxHardwareStatus_Processor>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const LinuxHardwareStatus_Processor& from);
  void MergeFrom(const LinuxHardwareStatus_Processor& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LinuxHardwareStatus_Processor* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  typedef LinuxHardwareStatus_Processor_LoadAverages LoadAverages;
 
  // accessors -------------------------------------------------------
 
  // optional .jaiabot.protobuf.LinuxHardwareStatus.Processor.LoadAverages loads = 10;
  bool has_loads() const;
  void clear_loads();
  static const int kLoadsFieldNumber = 10;
  private:
  const ::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages& _internal_loads() const;
  public:
  const ::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages& loads() const;
  ::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages* release_loads();
  ::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages* mutable_loads();
  void set_allocated_loads(::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages* loads);
 
  // optional int32 num_processes = 15;
  bool has_num_processes() const;
  void clear_num_processes();
  static const int kNumProcessesFieldNumber = 15;
  ::google::protobuf::int32 num_processes() const;
  void set_num_processes(::google::protobuf::int32 value);
 
  // optional int32 num_processors = 20;
  bool has_num_processors() const;
  void clear_num_processors();
  static const int kNumProcessorsFieldNumber = 20;
  ::google::protobuf::int32 num_processors() const;
  void set_num_processors(::google::protobuf::int32 value);
 
  // @@protoc_insertion_point(class_scope:jaiabot.protobuf.LinuxHardwareStatus.Processor)
 private:
  void set_has_loads();
  void clear_has_loads();
  void set_has_num_processes();
  void clear_has_num_processes();
  void set_has_num_processors();
  void clear_has_num_processors();
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages* loads_;
  ::google::protobuf::int32 num_processes_;
  ::google::protobuf::int32 num_processors_;
  friend struct ::protobuf_jaiabot_2fmessages_2fhealth_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class LinuxHardwareStatus_Information : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:jaiabot.protobuf.LinuxHardwareStatus.Information) */ {
 public:
  LinuxHardwareStatus_Information();
  virtual ~LinuxHardwareStatus_Information();
 
  LinuxHardwareStatus_Information(const LinuxHardwareStatus_Information& from);
 
  inline LinuxHardwareStatus_Information& operator=(const LinuxHardwareStatus_Information& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  LinuxHardwareStatus_Information(LinuxHardwareStatus_Information&& from) noexcept
    : LinuxHardwareStatus_Information() {
    *this = ::std::move(from);
  }
 
  inline LinuxHardwareStatus_Information& operator=(LinuxHardwareStatus_Information&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const LinuxHardwareStatus_Information& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const LinuxHardwareStatus_Information* internal_default_instance() {
    return reinterpret_cast<const LinuxHardwareStatus_Information*>(
               &_LinuxHardwareStatus_Information_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;
 
  void Swap(LinuxHardwareStatus_Information* other);
  friend void swap(LinuxHardwareStatus_Information& a, LinuxHardwareStatus_Information& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline LinuxHardwareStatus_Information* New() const final {
    return CreateMaybeMessage<LinuxHardwareStatus_Information>(NULL);
  }
 
  LinuxHardwareStatus_Information* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<LinuxHardwareStatus_Information>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const LinuxHardwareStatus_Information& from);
  void MergeFrom(const LinuxHardwareStatus_Information& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LinuxHardwareStatus_Information* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // required uint64 total = 1 [(.dccl.field) = {
  bool has_total() const;
  void clear_total();
  static const int kTotalFieldNumber = 1;
  ::google::protobuf::uint64 total() const;
  void set_total(::google::protobuf::uint64 value);
 
  // required uint64 available = 2 [(.dccl.field) = {
  bool has_available() const;
  void clear_available();
  static const int kAvailableFieldNumber = 2;
  ::google::protobuf::uint64 available() const;
  void set_available(::google::protobuf::uint64 value);
 
  // required float use_percent = 3;
  bool has_use_percent() const;
  void clear_use_percent();
  static const int kUsePercentFieldNumber = 3;
  float use_percent() const;
  void set_use_percent(float value);
 
  typedef boost::units::make_scaled_unit<boost::units::information::byte_base_unit::unit_type , boost::units::scale<10, boost::units::static_rational<3> > >::type total_unit;
  
  template<typename Quantity >
    void set_total_with_units(Quantity value_w_units)
    { set_total(boost::units::quantity<total_unit,google::protobuf::uint64 >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity total_with_units() const
    { return Quantity(total() * total_unit()); };
  
  boost::units::quantity< total_unit,google::protobuf::uint64 > total_with_units() const
    { return total_with_units<boost::units::quantity< total_unit,google::protobuf::uint64 > >(); };
  
  typedef boost::units::make_scaled_unit<boost::units::information::byte_base_unit::unit_type , boost::units::scale<10, boost::units::static_rational<3> > >::type available_unit;
  
  template<typename Quantity >
    void set_available_with_units(Quantity value_w_units)
    { set_available(boost::units::quantity<available_unit,google::protobuf::uint64 >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity available_with_units() const
    { return Quantity(available() * available_unit()); };
  
  boost::units::quantity< available_unit,google::protobuf::uint64 > available_with_units() const
    { return available_with_units<boost::units::quantity< available_unit,google::protobuf::uint64 > >(); };
  
  // @@protoc_insertion_point(class_scope:jaiabot.protobuf.LinuxHardwareStatus.Information)
 private:
  void set_has_total();
  void clear_has_total();
  void set_has_available();
  void clear_has_available();
  void set_has_use_percent();
  void clear_has_use_percent();
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::uint64 total_;
  ::google::protobuf::uint64 available_;
  float use_percent_;
  friend struct ::protobuf_jaiabot_2fmessages_2fhealth_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class LinuxHardwareStatus_Memory : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:jaiabot.protobuf.LinuxHardwareStatus.Memory) */ {
 public:
  LinuxHardwareStatus_Memory();
  virtual ~LinuxHardwareStatus_Memory();
 
  LinuxHardwareStatus_Memory(const LinuxHardwareStatus_Memory& from);
 
  inline LinuxHardwareStatus_Memory& operator=(const LinuxHardwareStatus_Memory& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  LinuxHardwareStatus_Memory(LinuxHardwareStatus_Memory&& from) noexcept
    : LinuxHardwareStatus_Memory() {
    *this = ::std::move(from);
  }
 
  inline LinuxHardwareStatus_Memory& operator=(LinuxHardwareStatus_Memory&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const LinuxHardwareStatus_Memory& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const LinuxHardwareStatus_Memory* internal_default_instance() {
    return reinterpret_cast<const LinuxHardwareStatus_Memory*>(
               &_LinuxHardwareStatus_Memory_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;
 
  void Swap(LinuxHardwareStatus_Memory* other);
  friend void swap(LinuxHardwareStatus_Memory& a, LinuxHardwareStatus_Memory& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline LinuxHardwareStatus_Memory* New() const final {
    return CreateMaybeMessage<LinuxHardwareStatus_Memory>(NULL);
  }
 
  LinuxHardwareStatus_Memory* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<LinuxHardwareStatus_Memory>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const LinuxHardwareStatus_Memory& from);
  void MergeFrom(const LinuxHardwareStatus_Memory& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LinuxHardwareStatus_Memory* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // required .jaiabot.protobuf.LinuxHardwareStatus.Information ram = 1;
  bool has_ram() const;
  void clear_ram();
  static const int kRamFieldNumber = 1;
  private:
  const ::jaiabot::protobuf::LinuxHardwareStatus_Information& _internal_ram() const;
  public:
  const ::jaiabot::protobuf::LinuxHardwareStatus_Information& ram() const;
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* release_ram();
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* mutable_ram();
  void set_allocated_ram(::jaiabot::protobuf::LinuxHardwareStatus_Information* ram);
 
  // required .jaiabot.protobuf.LinuxHardwareStatus.Information swap = 2;
  bool has_swap() const;
  void clear_swap();
  static const int kSwapFieldNumber = 2;
  private:
  const ::jaiabot::protobuf::LinuxHardwareStatus_Information& _internal_swap() const;
  public:
  const ::jaiabot::protobuf::LinuxHardwareStatus_Information& swap() const;
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* release_swap();
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* mutable_swap();
  void set_allocated_swap(::jaiabot::protobuf::LinuxHardwareStatus_Information* swap);
 
  // @@protoc_insertion_point(class_scope:jaiabot.protobuf.LinuxHardwareStatus.Memory)
 private:
  void set_has_ram();
  void clear_has_ram();
  void set_has_swap();
  void clear_has_swap();
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* ram_;
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* swap_;
  friend struct ::protobuf_jaiabot_2fmessages_2fhealth_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class LinuxHardwareStatus_Disk : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:jaiabot.protobuf.LinuxHardwareStatus.Disk) */ {
 public:
  LinuxHardwareStatus_Disk();
  virtual ~LinuxHardwareStatus_Disk();
 
  LinuxHardwareStatus_Disk(const LinuxHardwareStatus_Disk& from);
 
  inline LinuxHardwareStatus_Disk& operator=(const LinuxHardwareStatus_Disk& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  LinuxHardwareStatus_Disk(LinuxHardwareStatus_Disk&& from) noexcept
    : LinuxHardwareStatus_Disk() {
    *this = ::std::move(from);
  }
 
  inline LinuxHardwareStatus_Disk& operator=(LinuxHardwareStatus_Disk&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const LinuxHardwareStatus_Disk& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const LinuxHardwareStatus_Disk* internal_default_instance() {
    return reinterpret_cast<const LinuxHardwareStatus_Disk*>(
               &_LinuxHardwareStatus_Disk_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;
 
  void Swap(LinuxHardwareStatus_Disk* other);
  friend void swap(LinuxHardwareStatus_Disk& a, LinuxHardwareStatus_Disk& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline LinuxHardwareStatus_Disk* New() const final {
    return CreateMaybeMessage<LinuxHardwareStatus_Disk>(NULL);
  }
 
  LinuxHardwareStatus_Disk* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<LinuxHardwareStatus_Disk>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const LinuxHardwareStatus_Disk& from);
  void MergeFrom(const LinuxHardwareStatus_Disk& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LinuxHardwareStatus_Disk* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional .jaiabot.protobuf.LinuxHardwareStatus.Information rootfs = 1;
  bool has_rootfs() const;
  void clear_rootfs();
  static const int kRootfsFieldNumber = 1;
  private:
  const ::jaiabot::protobuf::LinuxHardwareStatus_Information& _internal_rootfs() const;
  public:
  const ::jaiabot::protobuf::LinuxHardwareStatus_Information& rootfs() const;
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* release_rootfs();
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* mutable_rootfs();
  void set_allocated_rootfs(::jaiabot::protobuf::LinuxHardwareStatus_Information* rootfs);
 
  // optional .jaiabot.protobuf.LinuxHardwareStatus.Information data = 2;
  bool has_data() const;
  void clear_data();
  static const int kDataFieldNumber = 2;
  private:
  const ::jaiabot::protobuf::LinuxHardwareStatus_Information& _internal_data() const;
  public:
  const ::jaiabot::protobuf::LinuxHardwareStatus_Information& data() const;
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* release_data();
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* mutable_data();
  void set_allocated_data(::jaiabot::protobuf::LinuxHardwareStatus_Information* data);
 
  // @@protoc_insertion_point(class_scope:jaiabot.protobuf.LinuxHardwareStatus.Disk)
 private:
  void set_has_rootfs();
  void clear_has_rootfs();
  void set_has_data();
  void clear_has_data();
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* rootfs_;
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* data_;
  friend struct ::protobuf_jaiabot_2fmessages_2fhealth_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class LinuxHardwareStatus_WiFi : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:jaiabot.protobuf.LinuxHardwareStatus.WiFi) */ {
 public:
  LinuxHardwareStatus_WiFi();
  virtual ~LinuxHardwareStatus_WiFi();
 
  LinuxHardwareStatus_WiFi(const LinuxHardwareStatus_WiFi& from);
 
  inline LinuxHardwareStatus_WiFi& operator=(const LinuxHardwareStatus_WiFi& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  LinuxHardwareStatus_WiFi(LinuxHardwareStatus_WiFi&& from) noexcept
    : LinuxHardwareStatus_WiFi() {
    *this = ::std::move(from);
  }
 
  inline LinuxHardwareStatus_WiFi& operator=(LinuxHardwareStatus_WiFi&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const LinuxHardwareStatus_WiFi& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const LinuxHardwareStatus_WiFi* internal_default_instance() {
    return reinterpret_cast<const LinuxHardwareStatus_WiFi*>(
               &_LinuxHardwareStatus_WiFi_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;
 
  void Swap(LinuxHardwareStatus_WiFi* other);
  friend void swap(LinuxHardwareStatus_WiFi& a, LinuxHardwareStatus_WiFi& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline LinuxHardwareStatus_WiFi* New() const final {
    return CreateMaybeMessage<LinuxHardwareStatus_WiFi>(NULL);
  }
 
  LinuxHardwareStatus_WiFi* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<LinuxHardwareStatus_WiFi>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const LinuxHardwareStatus_WiFi& from);
  void MergeFrom(const LinuxHardwareStatus_WiFi& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LinuxHardwareStatus_WiFi* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // required bool is_connected = 1;
  bool has_is_connected() const;
  void clear_is_connected();
  static const int kIsConnectedFieldNumber = 1;
  bool is_connected() const;
  void set_is_connected(bool value);
 
  // optional uint32 link_quality = 2;
  bool has_link_quality() const;
  void clear_link_quality();
  static const int kLinkQualityFieldNumber = 2;
  ::google::protobuf::uint32 link_quality() const;
  void set_link_quality(::google::protobuf::uint32 value);
 
  // optional uint32 link_quality_percentage = 3;
  bool has_link_quality_percentage() const;
  void clear_link_quality_percentage();
  static const int kLinkQualityPercentageFieldNumber = 3;
  ::google::protobuf::uint32 link_quality_percentage() const;
  void set_link_quality_percentage(::google::protobuf::uint32 value);
 
  // optional int32 signal_level = 4;
  bool has_signal_level() const;
  void clear_signal_level();
  static const int kSignalLevelFieldNumber = 4;
  ::google::protobuf::int32 signal_level() const;
  void set_signal_level(::google::protobuf::int32 value);
 
  // optional int32 noise_level = 5;
  bool has_noise_level() const;
  void clear_noise_level();
  static const int kNoiseLevelFieldNumber = 5;
  ::google::protobuf::int32 noise_level() const;
  void set_noise_level(::google::protobuf::int32 value);
 
  // @@protoc_insertion_point(class_scope:jaiabot.protobuf.LinuxHardwareStatus.WiFi)
 private:
  void set_has_is_connected();
  void clear_has_is_connected();
  void set_has_link_quality();
  void clear_has_link_quality();
  void set_has_link_quality_percentage();
  void clear_has_link_quality_percentage();
  void set_has_signal_level();
  void clear_has_signal_level();
  void set_has_noise_level();
  void clear_has_noise_level();
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  bool is_connected_;
  ::google::protobuf::uint32 link_quality_;
  ::google::protobuf::uint32 link_quality_percentage_;
  ::google::protobuf::int32 signal_level_;
  ::google::protobuf::int32 noise_level_;
  friend struct ::protobuf_jaiabot_2fmessages_2fhealth_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class LinuxHardwareStatus : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:jaiabot.protobuf.LinuxHardwareStatus) */ {
 public:
  LinuxHardwareStatus();
  virtual ~LinuxHardwareStatus();
 
  LinuxHardwareStatus(const LinuxHardwareStatus& from);
 
  inline LinuxHardwareStatus& operator=(const LinuxHardwareStatus& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  LinuxHardwareStatus(LinuxHardwareStatus&& from) noexcept
    : LinuxHardwareStatus() {
    *this = ::std::move(from);
  }
 
  inline LinuxHardwareStatus& operator=(LinuxHardwareStatus&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const LinuxHardwareStatus& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const LinuxHardwareStatus* internal_default_instance() {
    return reinterpret_cast<const LinuxHardwareStatus*>(
               &_LinuxHardwareStatus_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;
 
  void Swap(LinuxHardwareStatus* other);
  friend void swap(LinuxHardwareStatus& a, LinuxHardwareStatus& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline LinuxHardwareStatus* New() const final {
    return CreateMaybeMessage<LinuxHardwareStatus>(NULL);
  }
 
  LinuxHardwareStatus* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<LinuxHardwareStatus>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const LinuxHardwareStatus& from);
  void MergeFrom(const LinuxHardwareStatus& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LinuxHardwareStatus* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  typedef LinuxHardwareStatus_Processor Processor;
  typedef LinuxHardwareStatus_Information Information;
  typedef LinuxHardwareStatus_Memory Memory;
  typedef LinuxHardwareStatus_Disk Disk;
  typedef LinuxHardwareStatus_WiFi WiFi;
 
  // accessors -------------------------------------------------------
 
  // optional .jaiabot.protobuf.LinuxHardwareStatus.Processor processor = 20;
  bool has_processor() const;
  void clear_processor();
  static const int kProcessorFieldNumber = 20;
  private:
  const ::jaiabot::protobuf::LinuxHardwareStatus_Processor& _internal_processor() const;
  public:
  const ::jaiabot::protobuf::LinuxHardwareStatus_Processor& processor() const;
  ::jaiabot::protobuf::LinuxHardwareStatus_Processor* release_processor();
  ::jaiabot::protobuf::LinuxHardwareStatus_Processor* mutable_processor();
  void set_allocated_processor(::jaiabot::protobuf::LinuxHardwareStatus_Processor* processor);
 
  // optional .jaiabot.protobuf.LinuxHardwareStatus.Memory memory = 30;
  bool has_memory() const;
  void clear_memory();
  static const int kMemoryFieldNumber = 30;
  private:
  const ::jaiabot::protobuf::LinuxHardwareStatus_Memory& _internal_memory() const;
  public:
  const ::jaiabot::protobuf::LinuxHardwareStatus_Memory& memory() const;
  ::jaiabot::protobuf::LinuxHardwareStatus_Memory* release_memory();
  ::jaiabot::protobuf::LinuxHardwareStatus_Memory* mutable_memory();
  void set_allocated_memory(::jaiabot::protobuf::LinuxHardwareStatus_Memory* memory);
 
  // optional .jaiabot.protobuf.LinuxHardwareStatus.Disk disk = 40;
  bool has_disk() const;
  void clear_disk();
  static const int kDiskFieldNumber = 40;
  private:
  const ::jaiabot::protobuf::LinuxHardwareStatus_Disk& _internal_disk() const;
  public:
  const ::jaiabot::protobuf::LinuxHardwareStatus_Disk& disk() const;
  ::jaiabot::protobuf::LinuxHardwareStatus_Disk* release_disk();
  ::jaiabot::protobuf::LinuxHardwareStatus_Disk* mutable_disk();
  void set_allocated_disk(::jaiabot::protobuf::LinuxHardwareStatus_Disk* disk);
 
  // optional .jaiabot.protobuf.LinuxHardwareStatus.WiFi wifi = 50;
  bool has_wifi() const;
  void clear_wifi();
  static const int kWifiFieldNumber = 50;
  private:
  const ::jaiabot::protobuf::LinuxHardwareStatus_WiFi& _internal_wifi() const;
  public:
  const ::jaiabot::protobuf::LinuxHardwareStatus_WiFi& wifi() const;
  ::jaiabot::protobuf::LinuxHardwareStatus_WiFi* release_wifi();
  ::jaiabot::protobuf::LinuxHardwareStatus_WiFi* mutable_wifi();
  void set_allocated_wifi(::jaiabot::protobuf::LinuxHardwareStatus_WiFi* wifi);
 
  // optional int32 uptime = 10 [(.dccl.field) = {
  bool has_uptime() const;
  void clear_uptime();
  static const int kUptimeFieldNumber = 10;
  ::google::protobuf::int32 uptime() const;
  void set_uptime(::google::protobuf::int32 value);
 
  typedef boost::units::derived_dimension< boost::units::time_base_dimension,1 >::type uptime_dimension;
  
  typedef boost::units::unit<uptime_dimension,boost::units::si::system> uptime_unit;
  
  template<typename Quantity >
    void set_uptime_with_units(Quantity value_w_units)
    { set_uptime(boost::units::quantity<uptime_unit,google::protobuf::int32 >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity uptime_with_units() const
    { return Quantity(uptime() * uptime_unit()); };
  
  boost::units::quantity< uptime_unit,google::protobuf::int32 > uptime_with_units() const
    { return uptime_with_units<boost::units::quantity< uptime_unit,google::protobuf::int32 > >(); };
  
  // @@protoc_insertion_point(class_scope:jaiabot.protobuf.LinuxHardwareStatus)
 private:
  void set_has_uptime();
  void clear_has_uptime();
  void set_has_processor();
  void clear_has_processor();
  void set_has_memory();
  void clear_has_memory();
  void set_has_disk();
  void clear_has_disk();
  void set_has_wifi();
  void clear_has_wifi();
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::jaiabot::protobuf::LinuxHardwareStatus_Processor* processor_;
  ::jaiabot::protobuf::LinuxHardwareStatus_Memory* memory_;
  ::jaiabot::protobuf::LinuxHardwareStatus_Disk* disk_;
  ::jaiabot::protobuf::LinuxHardwareStatus_WiFi* wifi_;
  ::google::protobuf::int32 uptime_;
  friend struct ::protobuf_jaiabot_2fmessages_2fhealth_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class NTPStatus_NTPPeer : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:jaiabot.protobuf.NTPStatus.NTPPeer) */ {
 public:
  NTPStatus_NTPPeer();
  virtual ~NTPStatus_NTPPeer();
 
  NTPStatus_NTPPeer(const NTPStatus_NTPPeer& from);
 
  inline NTPStatus_NTPPeer& operator=(const NTPStatus_NTPPeer& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  NTPStatus_NTPPeer(NTPStatus_NTPPeer&& from) noexcept
    : NTPStatus_NTPPeer() {
    *this = ::std::move(from);
  }
 
  inline NTPStatus_NTPPeer& operator=(NTPStatus_NTPPeer&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const NTPStatus_NTPPeer& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const NTPStatus_NTPPeer* internal_default_instance() {
    return reinterpret_cast<const NTPStatus_NTPPeer*>(
               &_NTPStatus_NTPPeer_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;
 
  void Swap(NTPStatus_NTPPeer* other);
  friend void swap(NTPStatus_NTPPeer& a, NTPStatus_NTPPeer& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline NTPStatus_NTPPeer* New() const final {
    return CreateMaybeMessage<NTPStatus_NTPPeer>(NULL);
  }
 
  NTPStatus_NTPPeer* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<NTPStatus_NTPPeer>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const NTPStatus_NTPPeer& from);
  void MergeFrom(const NTPStatus_NTPPeer& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NTPStatus_NTPPeer* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  typedef NTPStatus_NTPPeer_TallyCode TallyCode;
  static const TallyCode PEER_CODE_UNKNOWN =
    NTPStatus_NTPPeer_TallyCode_PEER_CODE_UNKNOWN;
  static const TallyCode PEER_NOT_VALID =
    NTPStatus_NTPPeer_TallyCode_PEER_NOT_VALID;
  static const TallyCode PEER_DISCARDED_BY_INTERSECTION =
    NTPStatus_NTPPeer_TallyCode_PEER_DISCARDED_BY_INTERSECTION;
  static const TallyCode PEER_DISCARDED_BY_TABLE_OVERFLOW =
    NTPStatus_NTPPeer_TallyCode_PEER_DISCARDED_BY_TABLE_OVERFLOW;
  static const TallyCode PEER_DISCARDED_BY_CLUSTER_ALGORITHM =
    NTPStatus_NTPPeer_TallyCode_PEER_DISCARDED_BY_CLUSTER_ALGORITHM;
  static const TallyCode PEER_INCLUDED_IN_COMBINE =
    NTPStatus_NTPPeer_TallyCode_PEER_INCLUDED_IN_COMBINE;
  static const TallyCode PEER_ALTERNATIVE_BACKUP =
    NTPStatus_NTPPeer_TallyCode_PEER_ALTERNATIVE_BACKUP;
  static const TallyCode PEER_SYSTEM_SYNC_SOURCE =
    NTPStatus_NTPPeer_TallyCode_PEER_SYSTEM_SYNC_SOURCE;
  static const TallyCode PEER_PPS_SYNC =
    NTPStatus_NTPPeer_TallyCode_PEER_PPS_SYNC;
  static inline bool TallyCode_IsValid(int value) {
    return NTPStatus_NTPPeer_TallyCode_IsValid(value);
  }
  static const TallyCode TallyCode_MIN =
    NTPStatus_NTPPeer_TallyCode_TallyCode_MIN;
  static const TallyCode TallyCode_MAX =
    NTPStatus_NTPPeer_TallyCode_TallyCode_MAX;
  static const int TallyCode_ARRAYSIZE =
    NTPStatus_NTPPeer_TallyCode_TallyCode_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  TallyCode_descriptor() {
    return NTPStatus_NTPPeer_TallyCode_descriptor();
  }
  static inline const ::std::string& TallyCode_Name(TallyCode value) {
    return NTPStatus_NTPPeer_TallyCode_Name(value);
  }
  static inline bool TallyCode_Parse(const ::std::string& name,
      TallyCode* value) {
    return NTPStatus_NTPPeer_TallyCode_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
 
  // required string remote = 2;
  bool has_remote() const;
  void clear_remote();
  static const int kRemoteFieldNumber = 2;
  const ::std::string& remote() const;
  void set_remote(const ::std::string& value);
  #if LANG_CXX11
  void set_remote(::std::string&& value);
  #endif
  void set_remote(const char* value);
  void set_remote(const char* value, size_t size);
  ::std::string* mutable_remote();
  ::std::string* release_remote();
  void set_allocated_remote(::std::string* remote);
 
  // required string refid = 3;
  bool has_refid() const;
  void clear_refid();
  static const int kRefidFieldNumber = 3;
  const ::std::string& refid() const;
  void set_refid(const ::std::string& value);
  #if LANG_CXX11
  void set_refid(::std::string&& value);
  #endif
  void set_refid(const char* value);
  void set_refid(const char* value, size_t size);
  ::std::string* mutable_refid();
  ::std::string* release_refid();
  void set_allocated_refid(::std::string* refid);
 
  // optional int32 reach = 7 [default = 0];
  bool has_reach() const;
  void clear_reach();
  static const int kReachFieldNumber = 7;
  ::google::protobuf::int32 reach() const;
  void set_reach(::google::protobuf::int32 value);
 
  // optional float jitter = 10 [default = nan, (.dccl.field) = {
  bool has_jitter() const;
  void clear_jitter();
  static const int kJitterFieldNumber = 10;
  float jitter() const;
  void set_jitter(float value);
 
  // required .jaiabot.protobuf.NTPStatus.NTPPeer.TallyCode tally_code = 1 [default = PEER_CODE_UNKNOWN];
  bool has_tally_code() const;
  void clear_tally_code();
  static const int kTallyCodeFieldNumber = 1;
  ::jaiabot::protobuf::NTPStatus_NTPPeer_TallyCode tally_code() const;
  void set_tally_code(::jaiabot::protobuf::NTPStatus_NTPPeer_TallyCode value);
 
  // optional int32 stratum = 4 [default = 16];
  bool has_stratum() const;
  void clear_stratum();
  static const int kStratumFieldNumber = 4;
  ::google::protobuf::int32 stratum() const;
  void set_stratum(::google::protobuf::int32 value);
 
  // optional int32 when = 5 [default = -1, (.dccl.field) = {
  bool has_when() const;
  void clear_when();
  static const int kWhenFieldNumber = 5;
  ::google::protobuf::int32 when() const;
  void set_when(::google::protobuf::int32 value);
 
  // optional int32 poll = 6 [default = -1, (.dccl.field) = {
  bool has_poll() const;
  void clear_poll();
  static const int kPollFieldNumber = 6;
  ::google::protobuf::int32 poll() const;
  void set_poll(::google::protobuf::int32 value);
 
  // optional float delay = 8 [default = nan, (.dccl.field) = {
  bool has_delay() const;
  void clear_delay();
  static const int kDelayFieldNumber = 8;
  float delay() const;
  void set_delay(float value);
 
  // optional float offset = 9 [default = nan, (.dccl.field) = {
  bool has_offset() const;
  void clear_offset();
  static const int kOffsetFieldNumber = 9;
  float offset() const;
  void set_offset(float value);
 
  typedef boost::units::derived_dimension< boost::units::time_base_dimension,1 >::type when_dimension;
  
  typedef boost::units::unit<when_dimension,boost::units::si::system> when_unit;
  
  template<typename Quantity >
    void set_when_with_units(Quantity value_w_units)
    { set_when(boost::units::quantity<when_unit,google::protobuf::int32 >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity when_with_units() const
    { return Quantity(when() * when_unit()); };
  
  boost::units::quantity< when_unit,google::protobuf::int32 > when_with_units() const
    { return when_with_units<boost::units::quantity< when_unit,google::protobuf::int32 > >(); };
  
  typedef boost::units::derived_dimension< boost::units::time_base_dimension,1 >::type poll_dimension;
  
  typedef boost::units::unit<poll_dimension,boost::units::si::system> poll_unit;
  
  template<typename Quantity >
    void set_poll_with_units(Quantity value_w_units)
    { set_poll(boost::units::quantity<poll_unit,google::protobuf::int32 >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity poll_with_units() const
    { return Quantity(poll() * poll_unit()); };
  
  boost::units::quantity< poll_unit,google::protobuf::int32 > poll_with_units() const
    { return poll_with_units<boost::units::quantity< poll_unit,google::protobuf::int32 > >(); };
  
  typedef boost::units::derived_dimension< boost::units::time_base_dimension,1 >::type delay_dimension;
  
  typedef boost::units::make_scaled_unit<boost::units::unit<delay_dimension,boost::units::si::system> , boost::units::scale<10, boost::units::static_rational<-3> > >::type delay_unit;
  
  template<typename Quantity >
    void set_delay_with_units(Quantity value_w_units)
    { set_delay(boost::units::quantity<delay_unit,float >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity delay_with_units() const
    { return Quantity(delay() * delay_unit()); };
  
  boost::units::quantity< delay_unit,float > delay_with_units() const
    { return delay_with_units<boost::units::quantity< delay_unit,float > >(); };
  
  typedef boost::units::derived_dimension< boost::units::time_base_dimension,1 >::type offset_dimension;
  
  typedef boost::units::make_scaled_unit<boost::units::unit<offset_dimension,boost::units::si::system> , boost::units::scale<10, boost::units::static_rational<-3> > >::type offset_unit;
  
  template<typename Quantity >
    void set_offset_with_units(Quantity value_w_units)
    { set_offset(boost::units::quantity<offset_unit,float >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity offset_with_units() const
    { return Quantity(offset() * offset_unit()); };
  
  boost::units::quantity< offset_unit,float > offset_with_units() const
    { return offset_with_units<boost::units::quantity< offset_unit,float > >(); };
  
  typedef boost::units::derived_dimension< boost::units::time_base_dimension,1 >::type jitter_dimension;
  
  typedef boost::units::make_scaled_unit<boost::units::unit<jitter_dimension,boost::units::si::system> , boost::units::scale<10, boost::units::static_rational<-3> > >::type jitter_unit;
  
  template<typename Quantity >
    void set_jitter_with_units(Quantity value_w_units)
    { set_jitter(boost::units::quantity<jitter_unit,float >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity jitter_with_units() const
    { return Quantity(jitter() * jitter_unit()); };
  
  boost::units::quantity< jitter_unit,float > jitter_with_units() const
    { return jitter_with_units<boost::units::quantity< jitter_unit,float > >(); };
  
  // @@protoc_insertion_point(class_scope:jaiabot.protobuf.NTPStatus.NTPPeer)
 private:
  void set_has_tally_code();
  void clear_has_tally_code();
  void set_has_remote();
  void clear_has_remote();
  void set_has_refid();
  void clear_has_refid();
  void set_has_stratum();
  void clear_has_stratum();
  void set_has_when();
  void clear_has_when();
  void set_has_poll();
  void clear_has_poll();
  void set_has_reach();
  void clear_has_reach();
  void set_has_delay();
  void clear_has_delay();
  void set_has_offset();
  void clear_has_offset();
  void set_has_jitter();
  void clear_has_jitter();
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr remote_;
  ::google::protobuf::internal::ArenaStringPtr refid_;
  ::google::protobuf::int32 reach_;
  float jitter_;
  int tally_code_;
  ::google::protobuf::int32 stratum_;
  ::google::protobuf::int32 when_;
  ::google::protobuf::int32 poll_;
  float delay_;
  float offset_;
  friend struct ::protobuf_jaiabot_2fmessages_2fhealth_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class NTPStatus : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:jaiabot.protobuf.NTPStatus) */ {
 public:
  NTPStatus();
  virtual ~NTPStatus();
 
  NTPStatus(const NTPStatus& from);
 
  inline NTPStatus& operator=(const NTPStatus& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  NTPStatus(NTPStatus&& from) noexcept
    : NTPStatus() {
    *this = ::std::move(from);
  }
 
  inline NTPStatus& operator=(NTPStatus&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const NTPStatus& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const NTPStatus* internal_default_instance() {
    return reinterpret_cast<const NTPStatus*>(
               &_NTPStatus_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;
 
  void Swap(NTPStatus* other);
  friend void swap(NTPStatus& a, NTPStatus& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline NTPStatus* New() const final {
    return CreateMaybeMessage<NTPStatus>(NULL);
  }
 
  NTPStatus* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<NTPStatus>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const NTPStatus& from);
  void MergeFrom(const NTPStatus& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NTPStatus* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  typedef NTPStatus_NTPPeer NTPPeer;
 
  typedef NTPStatus_SyncSource SyncSource;
  static const SyncSource SYNC_UNKNOWN =
    NTPStatus_SyncSource_SYNC_UNKNOWN;
  static const SyncSource SYNC_UNSPECIFIED =
    NTPStatus_SyncSource_SYNC_UNSPECIFIED;
  static const SyncSource SYNC_PPS =
    NTPStatus_SyncSource_SYNC_PPS;
  static const SyncSource SYNC_LF_RADIO =
    NTPStatus_SyncSource_SYNC_LF_RADIO;
  static const SyncSource SYNC_HF_RADIO =
    NTPStatus_SyncSource_SYNC_HF_RADIO;
  static const SyncSource SYNC_UHF_RADIO =
    NTPStatus_SyncSource_SYNC_UHF_RADIO;
  static const SyncSource SYNC_LOCAL =
    NTPStatus_SyncSource_SYNC_LOCAL;
  static const SyncSource SYNC_NTP =
    NTPStatus_SyncSource_SYNC_NTP;
  static const SyncSource SYNC_OTHER =
    NTPStatus_SyncSource_SYNC_OTHER;
  static const SyncSource SYNC_WRISTWATCH =
    NTPStatus_SyncSource_SYNC_WRISTWATCH;
  static const SyncSource SYNC_TELEPHONE =
    NTPStatus_SyncSource_SYNC_TELEPHONE;
  static inline bool SyncSource_IsValid(int value) {
    return NTPStatus_SyncSource_IsValid(value);
  }
  static const SyncSource SyncSource_MIN =
    NTPStatus_SyncSource_SyncSource_MIN;
  static const SyncSource SyncSource_MAX =
    NTPStatus_SyncSource_SyncSource_MAX;
  static const int SyncSource_ARRAYSIZE =
    NTPStatus_SyncSource_SyncSource_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  SyncSource_descriptor() {
    return NTPStatus_SyncSource_descriptor();
  }
  static inline const ::std::string& SyncSource_Name(SyncSource value) {
    return NTPStatus_SyncSource_Name(value);
  }
  static inline bool SyncSource_Parse(const ::std::string& name,
      SyncSource* value) {
    return NTPStatus_SyncSource_Parse(name, value);
  }
 
  typedef NTPStatus_LeapIndicator LeapIndicator;
  static const LeapIndicator LEAP_UNKNOWN =
    NTPStatus_LeapIndicator_LEAP_UNKNOWN;
  static const LeapIndicator LEAP_NONE =
    NTPStatus_LeapIndicator_LEAP_NONE;
  static const LeapIndicator LEAP_LAST_MINUTE_HAS_61_SECONDS =
    NTPStatus_LeapIndicator_LEAP_LAST_MINUTE_HAS_61_SECONDS;
  static const LeapIndicator LEAP_LAST_MINUTE_HAS_59_SECONDS =
    NTPStatus_LeapIndicator_LEAP_LAST_MINUTE_HAS_59_SECONDS;
  static const LeapIndicator LEAP_CLOCK_NOT_SYNCHRONIZED =
    NTPStatus_LeapIndicator_LEAP_CLOCK_NOT_SYNCHRONIZED;
  static inline bool LeapIndicator_IsValid(int value) {
    return NTPStatus_LeapIndicator_IsValid(value);
  }
  static const LeapIndicator LeapIndicator_MIN =
    NTPStatus_LeapIndicator_LeapIndicator_MIN;
  static const LeapIndicator LeapIndicator_MAX =
    NTPStatus_LeapIndicator_LeapIndicator_MAX;
  static const int LeapIndicator_ARRAYSIZE =
    NTPStatus_LeapIndicator_LeapIndicator_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  LeapIndicator_descriptor() {
    return NTPStatus_LeapIndicator_descriptor();
  }
  static inline const ::std::string& LeapIndicator_Name(LeapIndicator value) {
    return NTPStatus_LeapIndicator_Name(value);
  }
  static inline bool LeapIndicator_Parse(const ::std::string& name,
      LeapIndicator* value) {
    return NTPStatus_LeapIndicator_Parse(name, value);
  }
 
  typedef NTPStatus_NTPSystemEvent NTPSystemEvent;
  static const NTPSystemEvent NTP_SYSTEM_EVENT_UNKNOWN =
    NTPStatus_NTPSystemEvent_NTP_SYSTEM_EVENT_UNKNOWN;
  static const NTPSystemEvent NTP_SYSTEM_EVENT_UNSPECIFIED =
    NTPStatus_NTPSystemEvent_NTP_SYSTEM_EVENT_UNSPECIFIED;
  static const NTPSystemEvent NTP_SYSTEM_FREQ_NOT_SET =
    NTPStatus_NTPSystemEvent_NTP_SYSTEM_FREQ_NOT_SET;
  static const NTPSystemEvent NTP_SYSTEM_FREQ_SET =
    NTPStatus_NTPSystemEvent_NTP_SYSTEM_FREQ_SET;
  static const NTPSystemEvent NTP_SYSTEM_SPIKE_DETECT =
    NTPStatus_NTPSystemEvent_NTP_SYSTEM_SPIKE_DETECT;
  static const NTPSystemEvent NTP_SYSTEM_FREQ_MODE =
    NTPStatus_NTPSystemEvent_NTP_SYSTEM_FREQ_MODE;
  static const NTPSystemEvent NTP_SYSTEM_CLOCK_SYNC =
    NTPStatus_NTPSystemEvent_NTP_SYSTEM_CLOCK_SYNC;
  static const NTPSystemEvent NTP_SYSTEM_RESTART =
    NTPStatus_NTPSystemEvent_NTP_SYSTEM_RESTART;
  static const NTPSystemEvent NTP_SYSTEM_PANIC_STOP =
    NTPStatus_NTPSystemEvent_NTP_SYSTEM_PANIC_STOP;
  static const NTPSystemEvent NTP_SYSTEM_NO_SYSTEM_PEER =
    NTPStatus_NTPSystemEvent_NTP_SYSTEM_NO_SYSTEM_PEER;
  static const NTPSystemEvent NTP_SYSTEM_LEAP_ARMED =
    NTPStatus_NTPSystemEvent_NTP_SYSTEM_LEAP_ARMED;
  static const NTPSystemEvent NTP_SYSTEM_LEAP_DISARMED =
    NTPStatus_NTPSystemEvent_NTP_SYSTEM_LEAP_DISARMED;
  static const NTPSystemEvent NTP_SYSTEM_LEAP_EVENT =
    NTPStatus_NTPSystemEvent_NTP_SYSTEM_LEAP_EVENT;
  static const NTPSystemEvent NTP_SYSTEM_CLOCK_STEP =
    NTPStatus_NTPSystemEvent_NTP_SYSTEM_CLOCK_STEP;
  static const NTPSystemEvent NTP_SYSTEM_KERNEL_INFO =
    NTPStatus_NTPSystemEvent_NTP_SYSTEM_KERNEL_INFO;
  static const NTPSystemEvent NTP_SYSTEM_LEAPSECOND_VALUES_UPDATE_FROM_FILE =
    NTPStatus_NTPSystemEvent_NTP_SYSTEM_LEAPSECOND_VALUES_UPDATE_FROM_FILE;
  static const NTPSystemEvent NTP_SYSTEM_STALE_LEAPSECOND_VALUES =
    NTPStatus_NTPSystemEvent_NTP_SYSTEM_STALE_LEAPSECOND_VALUES;
  static inline bool NTPSystemEvent_IsValid(int value) {
    return NTPStatus_NTPSystemEvent_IsValid(value);
  }
  static const NTPSystemEvent NTPSystemEvent_MIN =
    NTPStatus_NTPSystemEvent_NTPSystemEvent_MIN;
  static const NTPSystemEvent NTPSystemEvent_MAX =
    NTPStatus_NTPSystemEvent_NTPSystemEvent_MAX;
  static const int NTPSystemEvent_ARRAYSIZE =
    NTPStatus_NTPSystemEvent_NTPSystemEvent_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  NTPSystemEvent_descriptor() {
    return NTPStatus_NTPSystemEvent_descriptor();
  }
  static inline const ::std::string& NTPSystemEvent_Name(NTPSystemEvent value) {
    return NTPStatus_NTPSystemEvent_Name(value);
  }
  static inline bool NTPSystemEvent_Parse(const ::std::string& name,
      NTPSystemEvent* value) {
    return NTPStatus_NTPSystemEvent_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
 
  // repeated .jaiabot.protobuf.NTPStatus.NTPPeer peer = 21;
  int peer_size() const;
  void clear_peer();
  static const int kPeerFieldNumber = 21;
  ::jaiabot::protobuf::NTPStatus_NTPPeer* mutable_peer(int index);
  ::google::protobuf::RepeatedPtrField< ::jaiabot::protobuf::NTPStatus_NTPPeer >*
      mutable_peer();
  const ::jaiabot::protobuf::NTPStatus_NTPPeer& peer(int index) const;
  ::jaiabot::protobuf::NTPStatus_NTPPeer* add_peer();
  const ::google::protobuf::RepeatedPtrField< ::jaiabot::protobuf::NTPStatus_NTPPeer >&
      peer() const;
 
  // optional .jaiabot.protobuf.NTPStatus.NTPPeer system_sync_peer = 20;
  bool has_system_sync_peer() const;
  void clear_system_sync_peer();
  static const int kSystemSyncPeerFieldNumber = 20;
  private:
  const ::jaiabot::protobuf::NTPStatus_NTPPeer& _internal_system_sync_peer() const;
  public:
  const ::jaiabot::protobuf::NTPStatus_NTPPeer& system_sync_peer() const;
  ::jaiabot::protobuf::NTPStatus_NTPPeer* release_system_sync_peer();
  ::jaiabot::protobuf::NTPStatus_NTPPeer* mutable_system_sync_peer();
  void set_allocated_system_sync_peer(::jaiabot::protobuf::NTPStatus_NTPPeer* system_sync_peer);
 
  // optional int32 system_event_counter = 12 [default = 0];
  bool has_system_event_counter() const;
  void clear_system_event_counter();
  static const int kSystemEventCounterFieldNumber = 12;
  ::google::protobuf::int32 system_event_counter() const;
  void set_system_event_counter(::google::protobuf::int32 value);
 
  // optional .jaiabot.protobuf.NTPStatus.NTPSystemEvent last_system_event = 13 [default = NTP_SYSTEM_EVENT_UNKNOWN];
  bool has_last_system_event() const;
  void clear_last_system_event();
  static const int kLastSystemEventFieldNumber = 13;
  ::jaiabot::protobuf::NTPStatus_NTPSystemEvent last_system_event() const;
  void set_last_system_event(::jaiabot::protobuf::NTPStatus_NTPSystemEvent value);
 
  // optional .jaiabot.protobuf.NTPStatus.SyncSource sync_source = 10 [default = SYNC_UNKNOWN];
  bool has_sync_source() const;
  void clear_sync_source();
  static const int kSyncSourceFieldNumber = 10;
  ::jaiabot::protobuf::NTPStatus_SyncSource sync_source() const;
  void set_sync_source(::jaiabot::protobuf::NTPStatus_SyncSource value);
 
  // optional .jaiabot.protobuf.NTPStatus.LeapIndicator leap_indicator = 11 [default = LEAP_UNKNOWN];
  bool has_leap_indicator() const;
  void clear_leap_indicator();
  static const int kLeapIndicatorFieldNumber = 11;
  ::jaiabot::protobuf::NTPStatus_LeapIndicator leap_indicator() const;
  void set_leap_indicator(::jaiabot::protobuf::NTPStatus_LeapIndicator value);
 
  // @@protoc_insertion_point(class_scope:jaiabot.protobuf.NTPStatus)
 private:
  void set_has_sync_source();
  void clear_has_sync_source();
  void set_has_leap_indicator();
  void clear_has_leap_indicator();
  void set_has_system_event_counter();
  void clear_has_system_event_counter();
  void set_has_last_system_event();
  void clear_has_last_system_event();
  void set_has_system_sync_peer();
  void clear_has_system_sync_peer();
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::jaiabot::protobuf::NTPStatus_NTPPeer > peer_;
  ::jaiabot::protobuf::NTPStatus_NTPPeer* system_sync_peer_;
  ::google::protobuf::int32 system_event_counter_;
  int last_system_event_;
  int sync_source_;
  int leap_indicator_;
  friend struct ::protobuf_jaiabot_2fmessages_2fhealth_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class HelmIVPStatus : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:jaiabot.protobuf.HelmIVPStatus) */ {
 public:
  HelmIVPStatus();
  virtual ~HelmIVPStatus();
 
  HelmIVPStatus(const HelmIVPStatus& from);
 
  inline HelmIVPStatus& operator=(const HelmIVPStatus& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  HelmIVPStatus(HelmIVPStatus&& from) noexcept
    : HelmIVPStatus() {
    *this = ::std::move(from);
  }
 
  inline HelmIVPStatus& operator=(HelmIVPStatus&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const HelmIVPStatus& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const HelmIVPStatus* internal_default_instance() {
    return reinterpret_cast<const HelmIVPStatus*>(
               &_HelmIVPStatus_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;
 
  void Swap(HelmIVPStatus* other);
  friend void swap(HelmIVPStatus& a, HelmIVPStatus& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline HelmIVPStatus* New() const final {
    return CreateMaybeMessage<HelmIVPStatus>(NULL);
  }
 
  HelmIVPStatus* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<HelmIVPStatus>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const HelmIVPStatus& from);
  void MergeFrom(const HelmIVPStatus& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(HelmIVPStatus* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional string helm_ivp_state = 1 [default = "PARK"];
  bool has_helm_ivp_state() const;
  void clear_helm_ivp_state();
  static const int kHelmIvpStateFieldNumber = 1;
  const ::std::string& helm_ivp_state() const;
  void set_helm_ivp_state(const ::std::string& value);
  #if LANG_CXX11
  void set_helm_ivp_state(::std::string&& value);
  #endif
  void set_helm_ivp_state(const char* value);
  void set_helm_ivp_state(const char* value, size_t size);
  ::std::string* mutable_helm_ivp_state();
  ::std::string* release_helm_ivp_state();
  void set_allocated_helm_ivp_state(::std::string* helm_ivp_state);
 
  // optional bool helm_ivp_desired_speed = 2 [default = false];
  bool has_helm_ivp_desired_speed() const;
  void clear_helm_ivp_desired_speed();
  static const int kHelmIvpDesiredSpeedFieldNumber = 2;
  bool helm_ivp_desired_speed() const;
  void set_helm_ivp_desired_speed(bool value);
 
  // optional bool helm_ivp_desired_heading = 3 [default = false];
  bool has_helm_ivp_desired_heading() const;
  void clear_helm_ivp_desired_heading();
  static const int kHelmIvpDesiredHeadingFieldNumber = 3;
  bool helm_ivp_desired_heading() const;
  void set_helm_ivp_desired_heading(bool value);
 
  // optional bool helm_ivp_desired_depth = 4 [default = false];
  bool has_helm_ivp_desired_depth() const;
  void clear_helm_ivp_desired_depth();
  static const int kHelmIvpDesiredDepthFieldNumber = 4;
  bool helm_ivp_desired_depth() const;
  void set_helm_ivp_desired_depth(bool value);
 
  // optional bool helm_ivp_data = 5 [default = false];
  bool has_helm_ivp_data() const;
  void clear_helm_ivp_data();
  static const int kHelmIvpDataFieldNumber = 5;
  bool helm_ivp_data() const;
  void set_helm_ivp_data(bool value);
 
  // @@protoc_insertion_point(class_scope:jaiabot.protobuf.HelmIVPStatus)
 private:
  void set_has_helm_ivp_state();
  void clear_has_helm_ivp_state();
  void set_has_helm_ivp_desired_speed();
  void clear_has_helm_ivp_desired_speed();
  void set_has_helm_ivp_desired_heading();
  void clear_has_helm_ivp_desired_heading();
  void set_has_helm_ivp_desired_depth();
  void clear_has_helm_ivp_desired_depth();
  void set_has_helm_ivp_data();
  void clear_has_helm_ivp_data();
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  public:
  static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string> _i_give_permission_to_break_this_code_default_helm_ivp_state_;
  private:
  ::google::protobuf::internal::ArenaStringPtr helm_ivp_state_;
  bool helm_ivp_desired_speed_;
  bool helm_ivp_desired_heading_;
  bool helm_ivp_desired_depth_;
  bool helm_ivp_data_;
  friend struct ::protobuf_jaiabot_2fmessages_2fhealth_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class ThreadHealth : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:jaiabot.protobuf.ThreadHealth) */ {
 public:
  ThreadHealth();
  virtual ~ThreadHealth();
 
  ThreadHealth(const ThreadHealth& from);
 
  inline ThreadHealth& operator=(const ThreadHealth& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ThreadHealth(ThreadHealth&& from) noexcept
    : ThreadHealth() {
    *this = ::std::move(from);
  }
 
  inline ThreadHealth& operator=(ThreadHealth&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const ThreadHealth& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ThreadHealth* internal_default_instance() {
    return reinterpret_cast<const ThreadHealth*>(
               &_ThreadHealth_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;
 
  void Swap(ThreadHealth* other);
  friend void swap(ThreadHealth& a, ThreadHealth& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline ThreadHealth* New() const final {
    return CreateMaybeMessage<ThreadHealth>(NULL);
  }
 
  ThreadHealth* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ThreadHealth>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ThreadHealth& from);
  void MergeFrom(const ThreadHealth& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ThreadHealth* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // repeated .jaiabot.protobuf.Error error = 1;
  int error_size() const;
  void clear_error();
  static const int kErrorFieldNumber = 1;
  ::jaiabot::protobuf::Error error(int index) const;
  void set_error(int index, ::jaiabot::protobuf::Error value);
  void add_error(::jaiabot::protobuf::Error value);
  const ::google::protobuf::RepeatedField<int>& error() const;
  ::google::protobuf::RepeatedField<int>* mutable_error();
 
  // repeated .jaiabot.protobuf.Warning warning = 2;
  int warning_size() const;
  void clear_warning();
  static const int kWarningFieldNumber = 2;
  ::jaiabot::protobuf::Warning warning(int index) const;
  void set_warning(int index, ::jaiabot::protobuf::Warning value);
  void add_warning(::jaiabot::protobuf::Warning value);
  const ::google::protobuf::RepeatedField<int>& warning() const;
  ::google::protobuf::RepeatedField<int>* mutable_warning();
 
  // @@protoc_insertion_point(class_scope:jaiabot.protobuf.ThreadHealth)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedField<int> error_;
  ::google::protobuf::RepeatedField<int> warning_;
  friend struct ::protobuf_jaiabot_2fmessages_2fhealth_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class VehicleHealth : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:jaiabot.protobuf.VehicleHealth) */ {
 public:
  VehicleHealth();
  virtual ~VehicleHealth();
 
  VehicleHealth(const VehicleHealth& from);
 
  inline VehicleHealth& operator=(const VehicleHealth& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  VehicleHealth(VehicleHealth&& from) noexcept
    : VehicleHealth() {
    *this = ::std::move(from);
  }
 
  inline VehicleHealth& operator=(VehicleHealth&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const VehicleHealth& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const VehicleHealth* internal_default_instance() {
    return reinterpret_cast<const VehicleHealth*>(
               &_VehicleHealth_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;
 
  void Swap(VehicleHealth* other);
  friend void swap(VehicleHealth& a, VehicleHealth& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline VehicleHealth* New() const final {
    return CreateMaybeMessage<VehicleHealth>(NULL);
  }
 
  VehicleHealth* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<VehicleHealth>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const VehicleHealth& from);
  void MergeFrom(const VehicleHealth& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(VehicleHealth* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // @@protoc_insertion_point(class_scope:jaiabot.protobuf.VehicleHealth)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_jaiabot_2fmessages_2fhealth_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class SystemdStartReport : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:jaiabot.protobuf.SystemdStartReport) */ {
 public:
  SystemdStartReport();
  virtual ~SystemdStartReport();
 
  SystemdStartReport(const SystemdStartReport& from);
 
  inline SystemdStartReport& operator=(const SystemdStartReport& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SystemdStartReport(SystemdStartReport&& from) noexcept
    : SystemdStartReport() {
    *this = ::std::move(from);
  }
 
  inline SystemdStartReport& operator=(SystemdStartReport&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const SystemdStartReport& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const SystemdStartReport* internal_default_instance() {
    return reinterpret_cast<const SystemdStartReport*>(
               &_SystemdStartReport_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;
 
  void Swap(SystemdStartReport* other);
  friend void swap(SystemdStartReport& a, SystemdStartReport& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline SystemdStartReport* New() const final {
    return CreateMaybeMessage<SystemdStartReport>(NULL);
  }
 
  SystemdStartReport* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SystemdStartReport>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SystemdStartReport& from);
  void MergeFrom(const SystemdStartReport& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SystemdStartReport* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // required .jaiabot.protobuf.Error clear_error = 1;
  bool has_clear_error() const;
  void clear_clear_error();
  static const int kClearErrorFieldNumber = 1;
  ::jaiabot::protobuf::Error clear_error() const;
  void set_clear_error(::jaiabot::protobuf::Error value);
 
  // @@protoc_insertion_point(class_scope:jaiabot.protobuf.SystemdStartReport)
 private:
  void set_has_clear_error();
  void clear_has_clear_error();
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  int clear_error_;
  friend struct ::protobuf_jaiabot_2fmessages_2fhealth_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class SystemdStopReport : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:jaiabot.protobuf.SystemdStopReport) */ {
 public:
  SystemdStopReport();
  virtual ~SystemdStopReport();
 
  SystemdStopReport(const SystemdStopReport& from);
 
  inline SystemdStopReport& operator=(const SystemdStopReport& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SystemdStopReport(SystemdStopReport&& from) noexcept
    : SystemdStopReport() {
    *this = ::std::move(from);
  }
 
  inline SystemdStopReport& operator=(SystemdStopReport&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const SystemdStopReport& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const SystemdStopReport* internal_default_instance() {
    return reinterpret_cast<const SystemdStopReport*>(
               &_SystemdStopReport_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;
 
  void Swap(SystemdStopReport* other);
  friend void swap(SystemdStopReport& a, SystemdStopReport& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline SystemdStopReport* New() const final {
    return CreateMaybeMessage<SystemdStopReport>(NULL);
  }
 
  SystemdStopReport* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SystemdStopReport>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SystemdStopReport& from);
  void MergeFrom(const SystemdStopReport& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SystemdStopReport* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  typedef SystemdStopReport_ServiceResult ServiceResult;
  static const ServiceResult SERVICE_RESULT_UNKNOWN =
    SystemdStopReport_ServiceResult_SERVICE_RESULT_UNKNOWN;
  static const ServiceResult SERVICE_RESULT_SUCCESS =
    SystemdStopReport_ServiceResult_SERVICE_RESULT_SUCCESS;
  static const ServiceResult SERVICE_RESULT_PROTOCOL =
    SystemdStopReport_ServiceResult_SERVICE_RESULT_PROTOCOL;
  static const ServiceResult SERVICE_RESULT_TIMEOUT =
    SystemdStopReport_ServiceResult_SERVICE_RESULT_TIMEOUT;
  static const ServiceResult SERVICE_RESULT_EXIT_CODE =
    SystemdStopReport_ServiceResult_SERVICE_RESULT_EXIT_CODE;
  static const ServiceResult SERVICE_RESULT_SIGNAL =
    SystemdStopReport_ServiceResult_SERVICE_RESULT_SIGNAL;
  static const ServiceResult SERVICE_RESULT_CORE_DUMP =
    SystemdStopReport_ServiceResult_SERVICE_RESULT_CORE_DUMP;
  static const ServiceResult SERVICE_RESULT_WATCHDOG =
    SystemdStopReport_ServiceResult_SERVICE_RESULT_WATCHDOG;
  static const ServiceResult SERVICE_RESULT_START_LIMIT_HIT =
    SystemdStopReport_ServiceResult_SERVICE_RESULT_START_LIMIT_HIT;
  static const ServiceResult SERVICE_RESULT_RESOURCES =
    SystemdStopReport_ServiceResult_SERVICE_RESULT_RESOURCES;
  static inline bool ServiceResult_IsValid(int value) {
    return SystemdStopReport_ServiceResult_IsValid(value);
  }
  static const ServiceResult ServiceResult_MIN =
    SystemdStopReport_ServiceResult_ServiceResult_MIN;
  static const ServiceResult ServiceResult_MAX =
    SystemdStopReport_ServiceResult_ServiceResult_MAX;
  static const int ServiceResult_ARRAYSIZE =
    SystemdStopReport_ServiceResult_ServiceResult_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  ServiceResult_descriptor() {
    return SystemdStopReport_ServiceResult_descriptor();
  }
  static inline const ::std::string& ServiceResult_Name(ServiceResult value) {
    return SystemdStopReport_ServiceResult_Name(value);
  }
  static inline bool ServiceResult_Parse(const ::std::string& name,
      ServiceResult* value) {
    return SystemdStopReport_ServiceResult_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
 
  // optional string journal_dump_file = 3;
  bool has_journal_dump_file() const;
  void clear_journal_dump_file();
  static const int kJournalDumpFileFieldNumber = 3;
  const ::std::string& journal_dump_file() const;
  void set_journal_dump_file(const ::std::string& value);
  #if LANG_CXX11
  void set_journal_dump_file(::std::string&& value);
  #endif
  void set_journal_dump_file(const char* value);
  void set_journal_dump_file(const char* value, size_t size);
  ::std::string* mutable_journal_dump_file();
  ::std::string* release_journal_dump_file();
  void set_allocated_journal_dump_file(::std::string* journal_dump_file);
 
  // required .jaiabot.protobuf.SystemdStopReport.ServiceResult result = 1;
  bool has_result() const;
  void clear_result();
  static const int kResultFieldNumber = 1;
  ::jaiabot::protobuf::SystemdStopReport_ServiceResult result() const;
  void set_result(::jaiabot::protobuf::SystemdStopReport_ServiceResult value);
 
  // required .jaiabot.protobuf.Error error = 2;
  bool has_error() const;
  void clear_error();
  static const int kErrorFieldNumber = 2;
  ::jaiabot::protobuf::Error error() const;
  void set_error(::jaiabot::protobuf::Error value);
 
  // @@protoc_insertion_point(class_scope:jaiabot.protobuf.SystemdStopReport)
 private:
  void set_has_result();
  void clear_has_result();
  void set_has_error();
  void clear_has_error();
  void set_has_journal_dump_file();
  void clear_has_journal_dump_file();
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr journal_dump_file_;
  int result_;
  int error_;
  friend struct ::protobuf_jaiabot_2fmessages_2fhealth_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class SystemdReportAck : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:jaiabot.protobuf.SystemdReportAck) */ {
 public:
  SystemdReportAck();
  virtual ~SystemdReportAck();
 
  SystemdReportAck(const SystemdReportAck& from);
 
  inline SystemdReportAck& operator=(const SystemdReportAck& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SystemdReportAck(SystemdReportAck&& from) noexcept
    : SystemdReportAck() {
    *this = ::std::move(from);
  }
 
  inline SystemdReportAck& operator=(SystemdReportAck&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const SystemdReportAck& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const SystemdReportAck* internal_default_instance() {
    return reinterpret_cast<const SystemdReportAck*>(
               &_SystemdReportAck_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;
 
  void Swap(SystemdReportAck* other);
  friend void swap(SystemdReportAck& a, SystemdReportAck& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline SystemdReportAck* New() const final {
    return CreateMaybeMessage<SystemdReportAck>(NULL);
  }
 
  SystemdReportAck* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SystemdReportAck>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SystemdReportAck& from);
  void MergeFrom(const SystemdReportAck& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SystemdReportAck* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // required .jaiabot.protobuf.Error error_ack = 1;
  bool has_error_ack() const;
  void clear_error_ack();
  static const int kErrorAckFieldNumber = 1;
  ::jaiabot::protobuf::Error error_ack() const;
  void set_error_ack(::jaiabot::protobuf::Error value);
 
  // @@protoc_insertion_point(class_scope:jaiabot.protobuf.SystemdReportAck)
 private:
  void set_has_error_ack();
  void clear_has_error_ack();
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  int error_ack_;
  friend struct ::protobuf_jaiabot_2fmessages_2fhealth_2eproto::TableStruct;
};
// ===================================================================
 
static const int kJaiabotThreadFieldNumber = 1000;
extern ::google::protobuf::internal::ExtensionIdentifier< ::goby::middleware::protobuf::ThreadHealth,
    ::google::protobuf::internal::MessageTypeTraits< ::jaiabot::protobuf::ThreadHealth >, 11, false >
  jaiabot_thread;
static const int kJaiabotVehicleFieldNumber = 1000;
extern ::google::protobuf::internal::ExtensionIdentifier< ::goby::middleware::protobuf::VehicleHealth,
    ::google::protobuf::internal::MessageTypeTraits< ::jaiabot::protobuf::VehicleHealth >, 11, false >
  jaiabot_vehicle;
 
// ===================================================================
 
#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// LinuxHardwareStatus_Processor_LoadAverages
 
// required float one_min = 1;
inline bool LinuxHardwareStatus_Processor_LoadAverages::has_one_min() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void LinuxHardwareStatus_Processor_LoadAverages::set_has_one_min() {
  _has_bits_[0] |= 0x00000001u;
}
inline void LinuxHardwareStatus_Processor_LoadAverages::clear_has_one_min() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void LinuxHardwareStatus_Processor_LoadAverages::clear_one_min() {
  one_min_ = 0;
  clear_has_one_min();
}
inline float LinuxHardwareStatus_Processor_LoadAverages::one_min() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.Processor.LoadAverages.one_min)
  return one_min_;
}
inline void LinuxHardwareStatus_Processor_LoadAverages::set_one_min(float value) {
  set_has_one_min();
  one_min_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.LinuxHardwareStatus.Processor.LoadAverages.one_min)
}
 
// required float five_min = 2;
inline bool LinuxHardwareStatus_Processor_LoadAverages::has_five_min() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void LinuxHardwareStatus_Processor_LoadAverages::set_has_five_min() {
  _has_bits_[0] |= 0x00000002u;
}
inline void LinuxHardwareStatus_Processor_LoadAverages::clear_has_five_min() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void LinuxHardwareStatus_Processor_LoadAverages::clear_five_min() {
  five_min_ = 0;
  clear_has_five_min();
}
inline float LinuxHardwareStatus_Processor_LoadAverages::five_min() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.Processor.LoadAverages.five_min)
  return five_min_;
}
inline void LinuxHardwareStatus_Processor_LoadAverages::set_five_min(float value) {
  set_has_five_min();
  five_min_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.LinuxHardwareStatus.Processor.LoadAverages.five_min)
}
 
// required float fifteen_min = 3;
inline bool LinuxHardwareStatus_Processor_LoadAverages::has_fifteen_min() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void LinuxHardwareStatus_Processor_LoadAverages::set_has_fifteen_min() {
  _has_bits_[0] |= 0x00000004u;
}
inline void LinuxHardwareStatus_Processor_LoadAverages::clear_has_fifteen_min() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void LinuxHardwareStatus_Processor_LoadAverages::clear_fifteen_min() {
  fifteen_min_ = 0;
  clear_has_fifteen_min();
}
inline float LinuxHardwareStatus_Processor_LoadAverages::fifteen_min() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.Processor.LoadAverages.fifteen_min)
  return fifteen_min_;
}
inline void LinuxHardwareStatus_Processor_LoadAverages::set_fifteen_min(float value) {
  set_has_fifteen_min();
  fifteen_min_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.LinuxHardwareStatus.Processor.LoadAverages.fifteen_min)
}
 
// -------------------------------------------------------------------
 
// LinuxHardwareStatus_Processor
 
// optional .jaiabot.protobuf.LinuxHardwareStatus.Processor.LoadAverages loads = 10;
inline bool LinuxHardwareStatus_Processor::has_loads() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void LinuxHardwareStatus_Processor::set_has_loads() {
  _has_bits_[0] |= 0x00000001u;
}
inline void LinuxHardwareStatus_Processor::clear_has_loads() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void LinuxHardwareStatus_Processor::clear_loads() {
  if (loads_ != NULL) loads_->Clear();
  clear_has_loads();
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages& LinuxHardwareStatus_Processor::_internal_loads() const {
  return *loads_;
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages& LinuxHardwareStatus_Processor::loads() const {
  const ::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages* p = loads_;
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.Processor.loads)
  return p != NULL ? *p : *reinterpret_cast<const ::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages*>(
      &::jaiabot::protobuf::_LinuxHardwareStatus_Processor_LoadAverages_default_instance_);
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages* LinuxHardwareStatus_Processor::release_loads() {
  // @@protoc_insertion_point(field_release:jaiabot.protobuf.LinuxHardwareStatus.Processor.loads)
  clear_has_loads();
  ::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages* temp = loads_;
  loads_ = NULL;
  return temp;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages* LinuxHardwareStatus_Processor::mutable_loads() {
  set_has_loads();
  if (loads_ == NULL) {
    auto* p = CreateMaybeMessage<::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages>(GetArenaNoVirtual());
    loads_ = p;
  }
  // @@protoc_insertion_point(field_mutable:jaiabot.protobuf.LinuxHardwareStatus.Processor.loads)
  return loads_;
}
inline void LinuxHardwareStatus_Processor::set_allocated_loads(::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages* loads) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete loads_;
  }
  if (loads) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      loads = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, loads, submessage_arena);
    }
    set_has_loads();
  } else {
    clear_has_loads();
  }
  loads_ = loads;
  // @@protoc_insertion_point(field_set_allocated:jaiabot.protobuf.LinuxHardwareStatus.Processor.loads)
}
 
// optional int32 num_processes = 15;
inline bool LinuxHardwareStatus_Processor::has_num_processes() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void LinuxHardwareStatus_Processor::set_has_num_processes() {
  _has_bits_[0] |= 0x00000002u;
}
inline void LinuxHardwareStatus_Processor::clear_has_num_processes() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void LinuxHardwareStatus_Processor::clear_num_processes() {
  num_processes_ = 0;
  clear_has_num_processes();
}
inline ::google::protobuf::int32 LinuxHardwareStatus_Processor::num_processes() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.Processor.num_processes)
  return num_processes_;
}
inline void LinuxHardwareStatus_Processor::set_num_processes(::google::protobuf::int32 value) {
  set_has_num_processes();
  num_processes_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.LinuxHardwareStatus.Processor.num_processes)
}
 
// optional int32 num_processors = 20;
inline bool LinuxHardwareStatus_Processor::has_num_processors() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void LinuxHardwareStatus_Processor::set_has_num_processors() {
  _has_bits_[0] |= 0x00000004u;
}
inline void LinuxHardwareStatus_Processor::clear_has_num_processors() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void LinuxHardwareStatus_Processor::clear_num_processors() {
  num_processors_ = 0;
  clear_has_num_processors();
}
inline ::google::protobuf::int32 LinuxHardwareStatus_Processor::num_processors() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.Processor.num_processors)
  return num_processors_;
}
inline void LinuxHardwareStatus_Processor::set_num_processors(::google::protobuf::int32 value) {
  set_has_num_processors();
  num_processors_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.LinuxHardwareStatus.Processor.num_processors)
}
 
// -------------------------------------------------------------------
 
// LinuxHardwareStatus_Information
 
// required uint64 total = 1 [(.dccl.field) = {
inline bool LinuxHardwareStatus_Information::has_total() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void LinuxHardwareStatus_Information::set_has_total() {
  _has_bits_[0] |= 0x00000001u;
}
inline void LinuxHardwareStatus_Information::clear_has_total() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void LinuxHardwareStatus_Information::clear_total() {
  total_ = GOOGLE_ULONGLONG(0);
  clear_has_total();
}
inline ::google::protobuf::uint64 LinuxHardwareStatus_Information::total() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.Information.total)
  return total_;
}
inline void LinuxHardwareStatus_Information::set_total(::google::protobuf::uint64 value) {
  set_has_total();
  total_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.LinuxHardwareStatus.Information.total)
}
 
// required uint64 available = 2 [(.dccl.field) = {
inline bool LinuxHardwareStatus_Information::has_available() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void LinuxHardwareStatus_Information::set_has_available() {
  _has_bits_[0] |= 0x00000002u;
}
inline void LinuxHardwareStatus_Information::clear_has_available() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void LinuxHardwareStatus_Information::clear_available() {
  available_ = GOOGLE_ULONGLONG(0);
  clear_has_available();
}
inline ::google::protobuf::uint64 LinuxHardwareStatus_Information::available() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.Information.available)
  return available_;
}
inline void LinuxHardwareStatus_Information::set_available(::google::protobuf::uint64 value) {
  set_has_available();
  available_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.LinuxHardwareStatus.Information.available)
}
 
// required float use_percent = 3;
inline bool LinuxHardwareStatus_Information::has_use_percent() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void LinuxHardwareStatus_Information::set_has_use_percent() {
  _has_bits_[0] |= 0x00000004u;
}
inline void LinuxHardwareStatus_Information::clear_has_use_percent() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void LinuxHardwareStatus_Information::clear_use_percent() {
  use_percent_ = 0;
  clear_has_use_percent();
}
inline float LinuxHardwareStatus_Information::use_percent() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.Information.use_percent)
  return use_percent_;
}
inline void LinuxHardwareStatus_Information::set_use_percent(float value) {
  set_has_use_percent();
  use_percent_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.LinuxHardwareStatus.Information.use_percent)
}
 
// -------------------------------------------------------------------
 
// LinuxHardwareStatus_Memory
 
// required .jaiabot.protobuf.LinuxHardwareStatus.Information ram = 1;
inline bool LinuxHardwareStatus_Memory::has_ram() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void LinuxHardwareStatus_Memory::set_has_ram() {
  _has_bits_[0] |= 0x00000001u;
}
inline void LinuxHardwareStatus_Memory::clear_has_ram() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void LinuxHardwareStatus_Memory::clear_ram() {
  if (ram_ != NULL) ram_->Clear();
  clear_has_ram();
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_Information& LinuxHardwareStatus_Memory::_internal_ram() const {
  return *ram_;
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_Information& LinuxHardwareStatus_Memory::ram() const {
  const ::jaiabot::protobuf::LinuxHardwareStatus_Information* p = ram_;
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.Memory.ram)
  return p != NULL ? *p : *reinterpret_cast<const ::jaiabot::protobuf::LinuxHardwareStatus_Information*>(
      &::jaiabot::protobuf::_LinuxHardwareStatus_Information_default_instance_);
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Information* LinuxHardwareStatus_Memory::release_ram() {
  // @@protoc_insertion_point(field_release:jaiabot.protobuf.LinuxHardwareStatus.Memory.ram)
  clear_has_ram();
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* temp = ram_;
  ram_ = NULL;
  return temp;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Information* LinuxHardwareStatus_Memory::mutable_ram() {
  set_has_ram();
  if (ram_ == NULL) {
    auto* p = CreateMaybeMessage<::jaiabot::protobuf::LinuxHardwareStatus_Information>(GetArenaNoVirtual());
    ram_ = p;
  }
  // @@protoc_insertion_point(field_mutable:jaiabot.protobuf.LinuxHardwareStatus.Memory.ram)
  return ram_;
}
inline void LinuxHardwareStatus_Memory::set_allocated_ram(::jaiabot::protobuf::LinuxHardwareStatus_Information* ram) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete ram_;
  }
  if (ram) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      ram = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, ram, submessage_arena);
    }
    set_has_ram();
  } else {
    clear_has_ram();
  }
  ram_ = ram;
  // @@protoc_insertion_point(field_set_allocated:jaiabot.protobuf.LinuxHardwareStatus.Memory.ram)
}
 
// required .jaiabot.protobuf.LinuxHardwareStatus.Information swap = 2;
inline bool LinuxHardwareStatus_Memory::has_swap() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void LinuxHardwareStatus_Memory::set_has_swap() {
  _has_bits_[0] |= 0x00000002u;
}
inline void LinuxHardwareStatus_Memory::clear_has_swap() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void LinuxHardwareStatus_Memory::clear_swap() {
  if (swap_ != NULL) swap_->Clear();
  clear_has_swap();
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_Information& LinuxHardwareStatus_Memory::_internal_swap() const {
  return *swap_;
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_Information& LinuxHardwareStatus_Memory::swap() const {
  const ::jaiabot::protobuf::LinuxHardwareStatus_Information* p = swap_;
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.Memory.swap)
  return p != NULL ? *p : *reinterpret_cast<const ::jaiabot::protobuf::LinuxHardwareStatus_Information*>(
      &::jaiabot::protobuf::_LinuxHardwareStatus_Information_default_instance_);
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Information* LinuxHardwareStatus_Memory::release_swap() {
  // @@protoc_insertion_point(field_release:jaiabot.protobuf.LinuxHardwareStatus.Memory.swap)
  clear_has_swap();
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* temp = swap_;
  swap_ = NULL;
  return temp;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Information* LinuxHardwareStatus_Memory::mutable_swap() {
  set_has_swap();
  if (swap_ == NULL) {
    auto* p = CreateMaybeMessage<::jaiabot::protobuf::LinuxHardwareStatus_Information>(GetArenaNoVirtual());
    swap_ = p;
  }
  // @@protoc_insertion_point(field_mutable:jaiabot.protobuf.LinuxHardwareStatus.Memory.swap)
  return swap_;
}
inline void LinuxHardwareStatus_Memory::set_allocated_swap(::jaiabot::protobuf::LinuxHardwareStatus_Information* swap) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete swap_;
  }
  if (swap) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      swap = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, swap, submessage_arena);
    }
    set_has_swap();
  } else {
    clear_has_swap();
  }
  swap_ = swap;
  // @@protoc_insertion_point(field_set_allocated:jaiabot.protobuf.LinuxHardwareStatus.Memory.swap)
}
 
// -------------------------------------------------------------------
 
// LinuxHardwareStatus_Disk
 
// optional .jaiabot.protobuf.LinuxHardwareStatus.Information rootfs = 1;
inline bool LinuxHardwareStatus_Disk::has_rootfs() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void LinuxHardwareStatus_Disk::set_has_rootfs() {
  _has_bits_[0] |= 0x00000001u;
}
inline void LinuxHardwareStatus_Disk::clear_has_rootfs() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void LinuxHardwareStatus_Disk::clear_rootfs() {
  if (rootfs_ != NULL) rootfs_->Clear();
  clear_has_rootfs();
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_Information& LinuxHardwareStatus_Disk::_internal_rootfs() const {
  return *rootfs_;
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_Information& LinuxHardwareStatus_Disk::rootfs() const {
  const ::jaiabot::protobuf::LinuxHardwareStatus_Information* p = rootfs_;
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.Disk.rootfs)
  return p != NULL ? *p : *reinterpret_cast<const ::jaiabot::protobuf::LinuxHardwareStatus_Information*>(
      &::jaiabot::protobuf::_LinuxHardwareStatus_Information_default_instance_);
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Information* LinuxHardwareStatus_Disk::release_rootfs() {
  // @@protoc_insertion_point(field_release:jaiabot.protobuf.LinuxHardwareStatus.Disk.rootfs)
  clear_has_rootfs();
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* temp = rootfs_;
  rootfs_ = NULL;
  return temp;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Information* LinuxHardwareStatus_Disk::mutable_rootfs() {
  set_has_rootfs();
  if (rootfs_ == NULL) {
    auto* p = CreateMaybeMessage<::jaiabot::protobuf::LinuxHardwareStatus_Information>(GetArenaNoVirtual());
    rootfs_ = p;
  }
  // @@protoc_insertion_point(field_mutable:jaiabot.protobuf.LinuxHardwareStatus.Disk.rootfs)
  return rootfs_;
}
inline void LinuxHardwareStatus_Disk::set_allocated_rootfs(::jaiabot::protobuf::LinuxHardwareStatus_Information* rootfs) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete rootfs_;
  }
  if (rootfs) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      rootfs = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, rootfs, submessage_arena);
    }
    set_has_rootfs();
  } else {
    clear_has_rootfs();
  }
  rootfs_ = rootfs;
  // @@protoc_insertion_point(field_set_allocated:jaiabot.protobuf.LinuxHardwareStatus.Disk.rootfs)
}
 
// optional .jaiabot.protobuf.LinuxHardwareStatus.Information data = 2;
inline bool LinuxHardwareStatus_Disk::has_data() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void LinuxHardwareStatus_Disk::set_has_data() {
  _has_bits_[0] |= 0x00000002u;
}
inline void LinuxHardwareStatus_Disk::clear_has_data() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void LinuxHardwareStatus_Disk::clear_data() {
  if (data_ != NULL) data_->Clear();
  clear_has_data();
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_Information& LinuxHardwareStatus_Disk::_internal_data() const {
  return *data_;
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_Information& LinuxHardwareStatus_Disk::data() const {
  const ::jaiabot::protobuf::LinuxHardwareStatus_Information* p = data_;
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.Disk.data)
  return p != NULL ? *p : *reinterpret_cast<const ::jaiabot::protobuf::LinuxHardwareStatus_Information*>(
      &::jaiabot::protobuf::_LinuxHardwareStatus_Information_default_instance_);
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Information* LinuxHardwareStatus_Disk::release_data() {
  // @@protoc_insertion_point(field_release:jaiabot.protobuf.LinuxHardwareStatus.Disk.data)
  clear_has_data();
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* temp = data_;
  data_ = NULL;
  return temp;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Information* LinuxHardwareStatus_Disk::mutable_data() {
  set_has_data();
  if (data_ == NULL) {
    auto* p = CreateMaybeMessage<::jaiabot::protobuf::LinuxHardwareStatus_Information>(GetArenaNoVirtual());
    data_ = p;
  }
  // @@protoc_insertion_point(field_mutable:jaiabot.protobuf.LinuxHardwareStatus.Disk.data)
  return data_;
}
inline void LinuxHardwareStatus_Disk::set_allocated_data(::jaiabot::protobuf::LinuxHardwareStatus_Information* data) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete data_;
  }
  if (data) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      data = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, data, submessage_arena);
    }
    set_has_data();
  } else {
    clear_has_data();
  }
  data_ = data;
  // @@protoc_insertion_point(field_set_allocated:jaiabot.protobuf.LinuxHardwareStatus.Disk.data)
}
 
// -------------------------------------------------------------------
 
// LinuxHardwareStatus_WiFi
 
// required bool is_connected = 1;
inline bool LinuxHardwareStatus_WiFi::has_is_connected() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void LinuxHardwareStatus_WiFi::set_has_is_connected() {
  _has_bits_[0] |= 0x00000001u;
}
inline void LinuxHardwareStatus_WiFi::clear_has_is_connected() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void LinuxHardwareStatus_WiFi::clear_is_connected() {
  is_connected_ = false;
  clear_has_is_connected();
}
inline bool LinuxHardwareStatus_WiFi::is_connected() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.WiFi.is_connected)
  return is_connected_;
}
inline void LinuxHardwareStatus_WiFi::set_is_connected(bool value) {
  set_has_is_connected();
  is_connected_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.LinuxHardwareStatus.WiFi.is_connected)
}
 
// optional uint32 link_quality = 2;
inline bool LinuxHardwareStatus_WiFi::has_link_quality() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void LinuxHardwareStatus_WiFi::set_has_link_quality() {
  _has_bits_[0] |= 0x00000002u;
}
inline void LinuxHardwareStatus_WiFi::clear_has_link_quality() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void LinuxHardwareStatus_WiFi::clear_link_quality() {
  link_quality_ = 0u;
  clear_has_link_quality();
}
inline ::google::protobuf::uint32 LinuxHardwareStatus_WiFi::link_quality() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.WiFi.link_quality)
  return link_quality_;
}
inline void LinuxHardwareStatus_WiFi::set_link_quality(::google::protobuf::uint32 value) {
  set_has_link_quality();
  link_quality_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.LinuxHardwareStatus.WiFi.link_quality)
}
 
// optional uint32 link_quality_percentage = 3;
inline bool LinuxHardwareStatus_WiFi::has_link_quality_percentage() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void LinuxHardwareStatus_WiFi::set_has_link_quality_percentage() {
  _has_bits_[0] |= 0x00000004u;
}
inline void LinuxHardwareStatus_WiFi::clear_has_link_quality_percentage() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void LinuxHardwareStatus_WiFi::clear_link_quality_percentage() {
  link_quality_percentage_ = 0u;
  clear_has_link_quality_percentage();
}
inline ::google::protobuf::uint32 LinuxHardwareStatus_WiFi::link_quality_percentage() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.WiFi.link_quality_percentage)
  return link_quality_percentage_;
}
inline void LinuxHardwareStatus_WiFi::set_link_quality_percentage(::google::protobuf::uint32 value) {
  set_has_link_quality_percentage();
  link_quality_percentage_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.LinuxHardwareStatus.WiFi.link_quality_percentage)
}
 
// optional int32 signal_level = 4;
inline bool LinuxHardwareStatus_WiFi::has_signal_level() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void LinuxHardwareStatus_WiFi::set_has_signal_level() {
  _has_bits_[0] |= 0x00000008u;
}
inline void LinuxHardwareStatus_WiFi::clear_has_signal_level() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void LinuxHardwareStatus_WiFi::clear_signal_level() {
  signal_level_ = 0;
  clear_has_signal_level();
}
inline ::google::protobuf::int32 LinuxHardwareStatus_WiFi::signal_level() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.WiFi.signal_level)
  return signal_level_;
}
inline void LinuxHardwareStatus_WiFi::set_signal_level(::google::protobuf::int32 value) {
  set_has_signal_level();
  signal_level_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.LinuxHardwareStatus.WiFi.signal_level)
}
 
// optional int32 noise_level = 5;
inline bool LinuxHardwareStatus_WiFi::has_noise_level() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void LinuxHardwareStatus_WiFi::set_has_noise_level() {
  _has_bits_[0] |= 0x00000010u;
}
inline void LinuxHardwareStatus_WiFi::clear_has_noise_level() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void LinuxHardwareStatus_WiFi::clear_noise_level() {
  noise_level_ = 0;
  clear_has_noise_level();
}
inline ::google::protobuf::int32 LinuxHardwareStatus_WiFi::noise_level() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.WiFi.noise_level)
  return noise_level_;
}
inline void LinuxHardwareStatus_WiFi::set_noise_level(::google::protobuf::int32 value) {
  set_has_noise_level();
  noise_level_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.LinuxHardwareStatus.WiFi.noise_level)
}
 
// -------------------------------------------------------------------
 
// LinuxHardwareStatus
 
// optional int32 uptime = 10 [(.dccl.field) = {
inline bool LinuxHardwareStatus::has_uptime() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void LinuxHardwareStatus::set_has_uptime() {
  _has_bits_[0] |= 0x00000010u;
}
inline void LinuxHardwareStatus::clear_has_uptime() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void LinuxHardwareStatus::clear_uptime() {
  uptime_ = 0;
  clear_has_uptime();
}
inline ::google::protobuf::int32 LinuxHardwareStatus::uptime() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.uptime)
  return uptime_;
}
inline void LinuxHardwareStatus::set_uptime(::google::protobuf::int32 value) {
  set_has_uptime();
  uptime_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.LinuxHardwareStatus.uptime)
}
 
// optional .jaiabot.protobuf.LinuxHardwareStatus.Processor processor = 20;
inline bool LinuxHardwareStatus::has_processor() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void LinuxHardwareStatus::set_has_processor() {
  _has_bits_[0] |= 0x00000001u;
}
inline void LinuxHardwareStatus::clear_has_processor() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void LinuxHardwareStatus::clear_processor() {
  if (processor_ != NULL) processor_->Clear();
  clear_has_processor();
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_Processor& LinuxHardwareStatus::_internal_processor() const {
  return *processor_;
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_Processor& LinuxHardwareStatus::processor() const {
  const ::jaiabot::protobuf::LinuxHardwareStatus_Processor* p = processor_;
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.processor)
  return p != NULL ? *p : *reinterpret_cast<const ::jaiabot::protobuf::LinuxHardwareStatus_Processor*>(
      &::jaiabot::protobuf::_LinuxHardwareStatus_Processor_default_instance_);
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Processor* LinuxHardwareStatus::release_processor() {
  // @@protoc_insertion_point(field_release:jaiabot.protobuf.LinuxHardwareStatus.processor)
  clear_has_processor();
  ::jaiabot::protobuf::LinuxHardwareStatus_Processor* temp = processor_;
  processor_ = NULL;
  return temp;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Processor* LinuxHardwareStatus::mutable_processor() {
  set_has_processor();
  if (processor_ == NULL) {
    auto* p = CreateMaybeMessage<::jaiabot::protobuf::LinuxHardwareStatus_Processor>(GetArenaNoVirtual());
    processor_ = p;
  }
  // @@protoc_insertion_point(field_mutable:jaiabot.protobuf.LinuxHardwareStatus.processor)
  return processor_;
}
inline void LinuxHardwareStatus::set_allocated_processor(::jaiabot::protobuf::LinuxHardwareStatus_Processor* processor) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete processor_;
  }
  if (processor) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      processor = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, processor, submessage_arena);
    }
    set_has_processor();
  } else {
    clear_has_processor();
  }
  processor_ = processor;
  // @@protoc_insertion_point(field_set_allocated:jaiabot.protobuf.LinuxHardwareStatus.processor)
}
 
// optional .jaiabot.protobuf.LinuxHardwareStatus.Memory memory = 30;
inline bool LinuxHardwareStatus::has_memory() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void LinuxHardwareStatus::set_has_memory() {
  _has_bits_[0] |= 0x00000002u;
}
inline void LinuxHardwareStatus::clear_has_memory() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void LinuxHardwareStatus::clear_memory() {
  if (memory_ != NULL) memory_->Clear();
  clear_has_memory();
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_Memory& LinuxHardwareStatus::_internal_memory() const {
  return *memory_;
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_Memory& LinuxHardwareStatus::memory() const {
  const ::jaiabot::protobuf::LinuxHardwareStatus_Memory* p = memory_;
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.memory)
  return p != NULL ? *p : *reinterpret_cast<const ::jaiabot::protobuf::LinuxHardwareStatus_Memory*>(
      &::jaiabot::protobuf::_LinuxHardwareStatus_Memory_default_instance_);
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Memory* LinuxHardwareStatus::release_memory() {
  // @@protoc_insertion_point(field_release:jaiabot.protobuf.LinuxHardwareStatus.memory)
  clear_has_memory();
  ::jaiabot::protobuf::LinuxHardwareStatus_Memory* temp = memory_;
  memory_ = NULL;
  return temp;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Memory* LinuxHardwareStatus::mutable_memory() {
  set_has_memory();
  if (memory_ == NULL) {
    auto* p = CreateMaybeMessage<::jaiabot::protobuf::LinuxHardwareStatus_Memory>(GetArenaNoVirtual());
    memory_ = p;
  }
  // @@protoc_insertion_point(field_mutable:jaiabot.protobuf.LinuxHardwareStatus.memory)
  return memory_;
}
inline void LinuxHardwareStatus::set_allocated_memory(::jaiabot::protobuf::LinuxHardwareStatus_Memory* memory) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete memory_;
  }
  if (memory) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      memory = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, memory, submessage_arena);
    }
    set_has_memory();
  } else {
    clear_has_memory();
  }
  memory_ = memory;
  // @@protoc_insertion_point(field_set_allocated:jaiabot.protobuf.LinuxHardwareStatus.memory)
}
 
// optional .jaiabot.protobuf.LinuxHardwareStatus.Disk disk = 40;
inline bool LinuxHardwareStatus::has_disk() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void LinuxHardwareStatus::set_has_disk() {
  _has_bits_[0] |= 0x00000004u;
}
inline void LinuxHardwareStatus::clear_has_disk() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void LinuxHardwareStatus::clear_disk() {
  if (disk_ != NULL) disk_->Clear();
  clear_has_disk();
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_Disk& LinuxHardwareStatus::_internal_disk() const {
  return *disk_;
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_Disk& LinuxHardwareStatus::disk() const {
  const ::jaiabot::protobuf::LinuxHardwareStatus_Disk* p = disk_;
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.disk)
  return p != NULL ? *p : *reinterpret_cast<const ::jaiabot::protobuf::LinuxHardwareStatus_Disk*>(
      &::jaiabot::protobuf::_LinuxHardwareStatus_Disk_default_instance_);
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Disk* LinuxHardwareStatus::release_disk() {
  // @@protoc_insertion_point(field_release:jaiabot.protobuf.LinuxHardwareStatus.disk)
  clear_has_disk();
  ::jaiabot::protobuf::LinuxHardwareStatus_Disk* temp = disk_;
  disk_ = NULL;
  return temp;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Disk* LinuxHardwareStatus::mutable_disk() {
  set_has_disk();
  if (disk_ == NULL) {
    auto* p = CreateMaybeMessage<::jaiabot::protobuf::LinuxHardwareStatus_Disk>(GetArenaNoVirtual());
    disk_ = p;
  }
  // @@protoc_insertion_point(field_mutable:jaiabot.protobuf.LinuxHardwareStatus.disk)
  return disk_;
}
inline void LinuxHardwareStatus::set_allocated_disk(::jaiabot::protobuf::LinuxHardwareStatus_Disk* disk) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete disk_;
  }
  if (disk) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      disk = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, disk, submessage_arena);
    }
    set_has_disk();
  } else {
    clear_has_disk();
  }
  disk_ = disk;
  // @@protoc_insertion_point(field_set_allocated:jaiabot.protobuf.LinuxHardwareStatus.disk)
}
 
// optional .jaiabot.protobuf.LinuxHardwareStatus.WiFi wifi = 50;
inline bool LinuxHardwareStatus::has_wifi() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void LinuxHardwareStatus::set_has_wifi() {
  _has_bits_[0] |= 0x00000008u;
}
inline void LinuxHardwareStatus::clear_has_wifi() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void LinuxHardwareStatus::clear_wifi() {
  if (wifi_ != NULL) wifi_->Clear();
  clear_has_wifi();
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_WiFi& LinuxHardwareStatus::_internal_wifi() const {
  return *wifi_;
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_WiFi& LinuxHardwareStatus::wifi() const {
  const ::jaiabot::protobuf::LinuxHardwareStatus_WiFi* p = wifi_;
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.wifi)
  return p != NULL ? *p : *reinterpret_cast<const ::jaiabot::protobuf::LinuxHardwareStatus_WiFi*>(
      &::jaiabot::protobuf::_LinuxHardwareStatus_WiFi_default_instance_);
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_WiFi* LinuxHardwareStatus::release_wifi() {
  // @@protoc_insertion_point(field_release:jaiabot.protobuf.LinuxHardwareStatus.wifi)
  clear_has_wifi();
  ::jaiabot::protobuf::LinuxHardwareStatus_WiFi* temp = wifi_;
  wifi_ = NULL;
  return temp;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_WiFi* LinuxHardwareStatus::mutable_wifi() {
  set_has_wifi();
  if (wifi_ == NULL) {
    auto* p = CreateMaybeMessage<::jaiabot::protobuf::LinuxHardwareStatus_WiFi>(GetArenaNoVirtual());
    wifi_ = p;
  }
  // @@protoc_insertion_point(field_mutable:jaiabot.protobuf.LinuxHardwareStatus.wifi)
  return wifi_;
}
inline void LinuxHardwareStatus::set_allocated_wifi(::jaiabot::protobuf::LinuxHardwareStatus_WiFi* wifi) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete wifi_;
  }
  if (wifi) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      wifi = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, wifi, submessage_arena);
    }
    set_has_wifi();
  } else {
    clear_has_wifi();
  }
  wifi_ = wifi;
  // @@protoc_insertion_point(field_set_allocated:jaiabot.protobuf.LinuxHardwareStatus.wifi)
}
 
// -------------------------------------------------------------------
 
// NTPStatus_NTPPeer
 
// required .jaiabot.protobuf.NTPStatus.NTPPeer.TallyCode tally_code = 1 [default = PEER_CODE_UNKNOWN];
inline bool NTPStatus_NTPPeer::has_tally_code() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void NTPStatus_NTPPeer::set_has_tally_code() {
  _has_bits_[0] |= 0x00000010u;
}
inline void NTPStatus_NTPPeer::clear_has_tally_code() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void NTPStatus_NTPPeer::clear_tally_code() {
  tally_code_ = -1;
  clear_has_tally_code();
}
inline ::jaiabot::protobuf::NTPStatus_NTPPeer_TallyCode NTPStatus_NTPPeer::tally_code() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.NTPStatus.NTPPeer.tally_code)
  return static_cast< ::jaiabot::protobuf::NTPStatus_NTPPeer_TallyCode >(tally_code_);
}
inline void NTPStatus_NTPPeer::set_tally_code(::jaiabot::protobuf::NTPStatus_NTPPeer_TallyCode value) {
  assert(::jaiabot::protobuf::NTPStatus_NTPPeer_TallyCode_IsValid(value));
  set_has_tally_code();
  tally_code_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.NTPStatus.NTPPeer.tally_code)
}
 
// required string remote = 2;
inline bool NTPStatus_NTPPeer::has_remote() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void NTPStatus_NTPPeer::set_has_remote() {
  _has_bits_[0] |= 0x00000001u;
}
inline void NTPStatus_NTPPeer::clear_has_remote() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void NTPStatus_NTPPeer::clear_remote() {
  remote_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_remote();
}
inline const ::std::string& NTPStatus_NTPPeer::remote() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.NTPStatus.NTPPeer.remote)
  return remote_.GetNoArena();
}
inline void NTPStatus_NTPPeer::set_remote(const ::std::string& value) {
  set_has_remote();
  remote_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.NTPStatus.NTPPeer.remote)
}
#if LANG_CXX11
inline void NTPStatus_NTPPeer::set_remote(::std::string&& value) {
  set_has_remote();
  remote_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:jaiabot.protobuf.NTPStatus.NTPPeer.remote)
}
#endif
inline void NTPStatus_NTPPeer::set_remote(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_remote();
  remote_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:jaiabot.protobuf.NTPStatus.NTPPeer.remote)
}
inline void NTPStatus_NTPPeer::set_remote(const char* value, size_t size) {
  set_has_remote();
  remote_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:jaiabot.protobuf.NTPStatus.NTPPeer.remote)
}
inline ::std::string* NTPStatus_NTPPeer::mutable_remote() {
  set_has_remote();
  // @@protoc_insertion_point(field_mutable:jaiabot.protobuf.NTPStatus.NTPPeer.remote)
  return remote_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* NTPStatus_NTPPeer::release_remote() {
  // @@protoc_insertion_point(field_release:jaiabot.protobuf.NTPStatus.NTPPeer.remote)
  if (!has_remote()) {
    return NULL;
  }
  clear_has_remote();
  return remote_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void NTPStatus_NTPPeer::set_allocated_remote(::std::string* remote) {
  if (remote != NULL) {
    set_has_remote();
  } else {
    clear_has_remote();
  }
  remote_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), remote);
  // @@protoc_insertion_point(field_set_allocated:jaiabot.protobuf.NTPStatus.NTPPeer.remote)
}
 
// required string refid = 3;
inline bool NTPStatus_NTPPeer::has_refid() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void NTPStatus_NTPPeer::set_has_refid() {
  _has_bits_[0] |= 0x00000002u;
}
inline void NTPStatus_NTPPeer::clear_has_refid() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void NTPStatus_NTPPeer::clear_refid() {
  refid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_refid();
}
inline const ::std::string& NTPStatus_NTPPeer::refid() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.NTPStatus.NTPPeer.refid)
  return refid_.GetNoArena();
}
inline void NTPStatus_NTPPeer::set_refid(const ::std::string& value) {
  set_has_refid();
  refid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.NTPStatus.NTPPeer.refid)
}
#if LANG_CXX11
inline void NTPStatus_NTPPeer::set_refid(::std::string&& value) {
  set_has_refid();
  refid_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:jaiabot.protobuf.NTPStatus.NTPPeer.refid)
}
#endif
inline void NTPStatus_NTPPeer::set_refid(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_refid();
  refid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:jaiabot.protobuf.NTPStatus.NTPPeer.refid)
}
inline void NTPStatus_NTPPeer::set_refid(const char* value, size_t size) {
  set_has_refid();
  refid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:jaiabot.protobuf.NTPStatus.NTPPeer.refid)
}
inline ::std::string* NTPStatus_NTPPeer::mutable_refid() {
  set_has_refid();
  // @@protoc_insertion_point(field_mutable:jaiabot.protobuf.NTPStatus.NTPPeer.refid)
  return refid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* NTPStatus_NTPPeer::release_refid() {
  // @@protoc_insertion_point(field_release:jaiabot.protobuf.NTPStatus.NTPPeer.refid)
  if (!has_refid()) {
    return NULL;
  }
  clear_has_refid();
  return refid_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void NTPStatus_NTPPeer::set_allocated_refid(::std::string* refid) {
  if (refid != NULL) {
    set_has_refid();
  } else {
    clear_has_refid();
  }
  refid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), refid);
  // @@protoc_insertion_point(field_set_allocated:jaiabot.protobuf.NTPStatus.NTPPeer.refid)
}
 
// optional int32 stratum = 4 [default = 16];
inline bool NTPStatus_NTPPeer::has_stratum() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void NTPStatus_NTPPeer::set_has_stratum() {
  _has_bits_[0] |= 0x00000020u;
}
inline void NTPStatus_NTPPeer::clear_has_stratum() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void NTPStatus_NTPPeer::clear_stratum() {
  stratum_ = 16;
  clear_has_stratum();
}
inline ::google::protobuf::int32 NTPStatus_NTPPeer::stratum() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.NTPStatus.NTPPeer.stratum)
  return stratum_;
}
inline void NTPStatus_NTPPeer::set_stratum(::google::protobuf::int32 value) {
  set_has_stratum();
  stratum_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.NTPStatus.NTPPeer.stratum)
}
 
// optional int32 when = 5 [default = -1, (.dccl.field) = {
inline bool NTPStatus_NTPPeer::has_when() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void NTPStatus_NTPPeer::set_has_when() {
  _has_bits_[0] |= 0x00000040u;
}
inline void NTPStatus_NTPPeer::clear_has_when() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void NTPStatus_NTPPeer::clear_when() {
  when_ = -1;
  clear_has_when();
}
inline ::google::protobuf::int32 NTPStatus_NTPPeer::when() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.NTPStatus.NTPPeer.when)
  return when_;
}
inline void NTPStatus_NTPPeer::set_when(::google::protobuf::int32 value) {
  set_has_when();
  when_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.NTPStatus.NTPPeer.when)
}
 
// optional int32 poll = 6 [default = -1, (.dccl.field) = {
inline bool NTPStatus_NTPPeer::has_poll() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void NTPStatus_NTPPeer::set_has_poll() {
  _has_bits_[0] |= 0x00000080u;
}
inline void NTPStatus_NTPPeer::clear_has_poll() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void NTPStatus_NTPPeer::clear_poll() {
  poll_ = -1;
  clear_has_poll();
}
inline ::google::protobuf::int32 NTPStatus_NTPPeer::poll() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.NTPStatus.NTPPeer.poll)
  return poll_;
}
inline void NTPStatus_NTPPeer::set_poll(::google::protobuf::int32 value) {
  set_has_poll();
  poll_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.NTPStatus.NTPPeer.poll)
}
 
// optional int32 reach = 7 [default = 0];
inline bool NTPStatus_NTPPeer::has_reach() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void NTPStatus_NTPPeer::set_has_reach() {
  _has_bits_[0] |= 0x00000004u;
}
inline void NTPStatus_NTPPeer::clear_has_reach() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void NTPStatus_NTPPeer::clear_reach() {
  reach_ = 0;
  clear_has_reach();
}
inline ::google::protobuf::int32 NTPStatus_NTPPeer::reach() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.NTPStatus.NTPPeer.reach)
  return reach_;
}
inline void NTPStatus_NTPPeer::set_reach(::google::protobuf::int32 value) {
  set_has_reach();
  reach_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.NTPStatus.NTPPeer.reach)
}
 
// optional float delay = 8 [default = nan, (.dccl.field) = {
inline bool NTPStatus_NTPPeer::has_delay() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void NTPStatus_NTPPeer::set_has_delay() {
  _has_bits_[0] |= 0x00000100u;
}
inline void NTPStatus_NTPPeer::clear_has_delay() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void NTPStatus_NTPPeer::clear_delay() {
  delay_ = static_cast<float>(::google::protobuf::internal::NaN());
  clear_has_delay();
}
inline float NTPStatus_NTPPeer::delay() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.NTPStatus.NTPPeer.delay)
  return delay_;
}
inline void NTPStatus_NTPPeer::set_delay(float value) {
  set_has_delay();
  delay_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.NTPStatus.NTPPeer.delay)
}
 
// optional float offset = 9 [default = nan, (.dccl.field) = {
inline bool NTPStatus_NTPPeer::has_offset() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void NTPStatus_NTPPeer::set_has_offset() {
  _has_bits_[0] |= 0x00000200u;
}
inline void NTPStatus_NTPPeer::clear_has_offset() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void NTPStatus_NTPPeer::clear_offset() {
  offset_ = static_cast<float>(::google::protobuf::internal::NaN());
  clear_has_offset();
}
inline float NTPStatus_NTPPeer::offset() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.NTPStatus.NTPPeer.offset)
  return offset_;
}
inline void NTPStatus_NTPPeer::set_offset(float value) {
  set_has_offset();
  offset_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.NTPStatus.NTPPeer.offset)
}
 
// optional float jitter = 10 [default = nan, (.dccl.field) = {
inline bool NTPStatus_NTPPeer::has_jitter() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void NTPStatus_NTPPeer::set_has_jitter() {
  _has_bits_[0] |= 0x00000008u;
}
inline void NTPStatus_NTPPeer::clear_has_jitter() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void NTPStatus_NTPPeer::clear_jitter() {
  jitter_ = static_cast<float>(::google::protobuf::internal::NaN());
  clear_has_jitter();
}
inline float NTPStatus_NTPPeer::jitter() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.NTPStatus.NTPPeer.jitter)
  return jitter_;
}
inline void NTPStatus_NTPPeer::set_jitter(float value) {
  set_has_jitter();
  jitter_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.NTPStatus.NTPPeer.jitter)
}
 
// -------------------------------------------------------------------
 
// NTPStatus
 
// optional .jaiabot.protobuf.NTPStatus.SyncSource sync_source = 10 [default = SYNC_UNKNOWN];
inline bool NTPStatus::has_sync_source() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void NTPStatus::set_has_sync_source() {
  _has_bits_[0] |= 0x00000008u;
}
inline void NTPStatus::clear_has_sync_source() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void NTPStatus::clear_sync_source() {
  sync_source_ = -1;
  clear_has_sync_source();
}
inline ::jaiabot::protobuf::NTPStatus_SyncSource NTPStatus::sync_source() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.NTPStatus.sync_source)
  return static_cast< ::jaiabot::protobuf::NTPStatus_SyncSource >(sync_source_);
}
inline void NTPStatus::set_sync_source(::jaiabot::protobuf::NTPStatus_SyncSource value) {
  assert(::jaiabot::protobuf::NTPStatus_SyncSource_IsValid(value));
  set_has_sync_source();
  sync_source_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.NTPStatus.sync_source)
}
 
// optional .jaiabot.protobuf.NTPStatus.LeapIndicator leap_indicator = 11 [default = LEAP_UNKNOWN];
inline bool NTPStatus::has_leap_indicator() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void NTPStatus::set_has_leap_indicator() {
  _has_bits_[0] |= 0x00000010u;
}
inline void NTPStatus::clear_has_leap_indicator() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void NTPStatus::clear_leap_indicator() {
  leap_indicator_ = -1;
  clear_has_leap_indicator();
}
inline ::jaiabot::protobuf::NTPStatus_LeapIndicator NTPStatus::leap_indicator() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.NTPStatus.leap_indicator)
  return static_cast< ::jaiabot::protobuf::NTPStatus_LeapIndicator >(leap_indicator_);
}
inline void NTPStatus::set_leap_indicator(::jaiabot::protobuf::NTPStatus_LeapIndicator value) {
  assert(::jaiabot::protobuf::NTPStatus_LeapIndicator_IsValid(value));
  set_has_leap_indicator();
  leap_indicator_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.NTPStatus.leap_indicator)
}
 
// optional int32 system_event_counter = 12 [default = 0];
inline bool NTPStatus::has_system_event_counter() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void NTPStatus::set_has_system_event_counter() {
  _has_bits_[0] |= 0x00000002u;
}
inline void NTPStatus::clear_has_system_event_counter() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void NTPStatus::clear_system_event_counter() {
  system_event_counter_ = 0;
  clear_has_system_event_counter();
}
inline ::google::protobuf::int32 NTPStatus::system_event_counter() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.NTPStatus.system_event_counter)
  return system_event_counter_;
}
inline void NTPStatus::set_system_event_counter(::google::protobuf::int32 value) {
  set_has_system_event_counter();
  system_event_counter_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.NTPStatus.system_event_counter)
}
 
// optional .jaiabot.protobuf.NTPStatus.NTPSystemEvent last_system_event = 13 [default = NTP_SYSTEM_EVENT_UNKNOWN];
inline bool NTPStatus::has_last_system_event() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void NTPStatus::set_has_last_system_event() {
  _has_bits_[0] |= 0x00000004u;
}
inline void NTPStatus::clear_has_last_system_event() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void NTPStatus::clear_last_system_event() {
  last_system_event_ = -1;
  clear_has_last_system_event();
}
inline ::jaiabot::protobuf::NTPStatus_NTPSystemEvent NTPStatus::last_system_event() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.NTPStatus.last_system_event)
  return static_cast< ::jaiabot::protobuf::NTPStatus_NTPSystemEvent >(last_system_event_);
}
inline void NTPStatus::set_last_system_event(::jaiabot::protobuf::NTPStatus_NTPSystemEvent value) {
  assert(::jaiabot::protobuf::NTPStatus_NTPSystemEvent_IsValid(value));
  set_has_last_system_event();
  last_system_event_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.NTPStatus.last_system_event)
}
 
// optional .jaiabot.protobuf.NTPStatus.NTPPeer system_sync_peer = 20;
inline bool NTPStatus::has_system_sync_peer() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void NTPStatus::set_has_system_sync_peer() {
  _has_bits_[0] |= 0x00000001u;
}
inline void NTPStatus::clear_has_system_sync_peer() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void NTPStatus::clear_system_sync_peer() {
  if (system_sync_peer_ != NULL) system_sync_peer_->Clear();
  clear_has_system_sync_peer();
}
inline const ::jaiabot::protobuf::NTPStatus_NTPPeer& NTPStatus::_internal_system_sync_peer() const {
  return *system_sync_peer_;
}
inline const ::jaiabot::protobuf::NTPStatus_NTPPeer& NTPStatus::system_sync_peer() const {
  const ::jaiabot::protobuf::NTPStatus_NTPPeer* p = system_sync_peer_;
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.NTPStatus.system_sync_peer)
  return p != NULL ? *p : *reinterpret_cast<const ::jaiabot::protobuf::NTPStatus_NTPPeer*>(
      &::jaiabot::protobuf::_NTPStatus_NTPPeer_default_instance_);
}
inline ::jaiabot::protobuf::NTPStatus_NTPPeer* NTPStatus::release_system_sync_peer() {
  // @@protoc_insertion_point(field_release:jaiabot.protobuf.NTPStatus.system_sync_peer)
  clear_has_system_sync_peer();
  ::jaiabot::protobuf::NTPStatus_NTPPeer* temp = system_sync_peer_;
  system_sync_peer_ = NULL;
  return temp;
}
inline ::jaiabot::protobuf::NTPStatus_NTPPeer* NTPStatus::mutable_system_sync_peer() {
  set_has_system_sync_peer();
  if (system_sync_peer_ == NULL) {
    auto* p = CreateMaybeMessage<::jaiabot::protobuf::NTPStatus_NTPPeer>(GetArenaNoVirtual());
    system_sync_peer_ = p;
  }
  // @@protoc_insertion_point(field_mutable:jaiabot.protobuf.NTPStatus.system_sync_peer)
  return system_sync_peer_;
}
inline void NTPStatus::set_allocated_system_sync_peer(::jaiabot::protobuf::NTPStatus_NTPPeer* system_sync_peer) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete system_sync_peer_;
  }
  if (system_sync_peer) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      system_sync_peer = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, system_sync_peer, submessage_arena);
    }
    set_has_system_sync_peer();
  } else {
    clear_has_system_sync_peer();
  }
  system_sync_peer_ = system_sync_peer;
  // @@protoc_insertion_point(field_set_allocated:jaiabot.protobuf.NTPStatus.system_sync_peer)
}
 
// repeated .jaiabot.protobuf.NTPStatus.NTPPeer peer = 21;
inline int NTPStatus::peer_size() const {
  return peer_.size();
}
inline void NTPStatus::clear_peer() {
  peer_.Clear();
}
inline ::jaiabot::protobuf::NTPStatus_NTPPeer* NTPStatus::mutable_peer(int index) {
  // @@protoc_insertion_point(field_mutable:jaiabot.protobuf.NTPStatus.peer)
  return peer_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::jaiabot::protobuf::NTPStatus_NTPPeer >*
NTPStatus::mutable_peer() {
  // @@protoc_insertion_point(field_mutable_list:jaiabot.protobuf.NTPStatus.peer)
  return &peer_;
}
inline const ::jaiabot::protobuf::NTPStatus_NTPPeer& NTPStatus::peer(int index) const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.NTPStatus.peer)
  return peer_.Get(index);
}
inline ::jaiabot::protobuf::NTPStatus_NTPPeer* NTPStatus::add_peer() {
  // @@protoc_insertion_point(field_add:jaiabot.protobuf.NTPStatus.peer)
  return peer_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::jaiabot::protobuf::NTPStatus_NTPPeer >&
NTPStatus::peer() const {
  // @@protoc_insertion_point(field_list:jaiabot.protobuf.NTPStatus.peer)
  return peer_;
}
 
// -------------------------------------------------------------------
 
// HelmIVPStatus
 
// optional string helm_ivp_state = 1 [default = "PARK"];
inline bool HelmIVPStatus::has_helm_ivp_state() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void HelmIVPStatus::set_has_helm_ivp_state() {
  _has_bits_[0] |= 0x00000001u;
}
inline void HelmIVPStatus::clear_has_helm_ivp_state() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void HelmIVPStatus::clear_helm_ivp_state() {
  helm_ivp_state_.ClearToDefaultNoArena(&::jaiabot::protobuf::HelmIVPStatus::_i_give_permission_to_break_this_code_default_helm_ivp_state_.get());
  clear_has_helm_ivp_state();
}
inline const ::std::string& HelmIVPStatus::helm_ivp_state() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.HelmIVPStatus.helm_ivp_state)
  return helm_ivp_state_.GetNoArena();
}
inline void HelmIVPStatus::set_helm_ivp_state(const ::std::string& value) {
  set_has_helm_ivp_state();
  helm_ivp_state_.SetNoArena(&::jaiabot::protobuf::HelmIVPStatus::_i_give_permission_to_break_this_code_default_helm_ivp_state_.get(), value);
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.HelmIVPStatus.helm_ivp_state)
}
#if LANG_CXX11
inline void HelmIVPStatus::set_helm_ivp_state(::std::string&& value) {
  set_has_helm_ivp_state();
  helm_ivp_state_.SetNoArena(
    &::jaiabot::protobuf::HelmIVPStatus::_i_give_permission_to_break_this_code_default_helm_ivp_state_.get(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:jaiabot.protobuf.HelmIVPStatus.helm_ivp_state)
}
#endif
inline void HelmIVPStatus::set_helm_ivp_state(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_helm_ivp_state();
  helm_ivp_state_.SetNoArena(&::jaiabot::protobuf::HelmIVPStatus::_i_give_permission_to_break_this_code_default_helm_ivp_state_.get(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:jaiabot.protobuf.HelmIVPStatus.helm_ivp_state)
}
inline void HelmIVPStatus::set_helm_ivp_state(const char* value, size_t size) {
  set_has_helm_ivp_state();
  helm_ivp_state_.SetNoArena(&::jaiabot::protobuf::HelmIVPStatus::_i_give_permission_to_break_this_code_default_helm_ivp_state_.get(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:jaiabot.protobuf.HelmIVPStatus.helm_ivp_state)
}
inline ::std::string* HelmIVPStatus::mutable_helm_ivp_state() {
  set_has_helm_ivp_state();
  // @@protoc_insertion_point(field_mutable:jaiabot.protobuf.HelmIVPStatus.helm_ivp_state)
  return helm_ivp_state_.MutableNoArena(&::jaiabot::protobuf::HelmIVPStatus::_i_give_permission_to_break_this_code_default_helm_ivp_state_.get());
}
inline ::std::string* HelmIVPStatus::release_helm_ivp_state() {
  // @@protoc_insertion_point(field_release:jaiabot.protobuf.HelmIVPStatus.helm_ivp_state)
  if (!has_helm_ivp_state()) {
    return NULL;
  }
  clear_has_helm_ivp_state();
  return helm_ivp_state_.ReleaseNonDefaultNoArena(&::jaiabot::protobuf::HelmIVPStatus::_i_give_permission_to_break_this_code_default_helm_ivp_state_.get());
}
inline void HelmIVPStatus::set_allocated_helm_ivp_state(::std::string* helm_ivp_state) {
  if (helm_ivp_state != NULL) {
    set_has_helm_ivp_state();
  } else {
    clear_has_helm_ivp_state();
  }
  helm_ivp_state_.SetAllocatedNoArena(&::jaiabot::protobuf::HelmIVPStatus::_i_give_permission_to_break_this_code_default_helm_ivp_state_.get(), helm_ivp_state);
  // @@protoc_insertion_point(field_set_allocated:jaiabot.protobuf.HelmIVPStatus.helm_ivp_state)
}
 
// optional bool helm_ivp_desired_speed = 2 [default = false];
inline bool HelmIVPStatus::has_helm_ivp_desired_speed() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void HelmIVPStatus::set_has_helm_ivp_desired_speed() {
  _has_bits_[0] |= 0x00000002u;
}
inline void HelmIVPStatus::clear_has_helm_ivp_desired_speed() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void HelmIVPStatus::clear_helm_ivp_desired_speed() {
  helm_ivp_desired_speed_ = false;
  clear_has_helm_ivp_desired_speed();
}
inline bool HelmIVPStatus::helm_ivp_desired_speed() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.HelmIVPStatus.helm_ivp_desired_speed)
  return helm_ivp_desired_speed_;
}
inline void HelmIVPStatus::set_helm_ivp_desired_speed(bool value) {
  set_has_helm_ivp_desired_speed();
  helm_ivp_desired_speed_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.HelmIVPStatus.helm_ivp_desired_speed)
}
 
// optional bool helm_ivp_desired_heading = 3 [default = false];
inline bool HelmIVPStatus::has_helm_ivp_desired_heading() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void HelmIVPStatus::set_has_helm_ivp_desired_heading() {
  _has_bits_[0] |= 0x00000004u;
}
inline void HelmIVPStatus::clear_has_helm_ivp_desired_heading() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void HelmIVPStatus::clear_helm_ivp_desired_heading() {
  helm_ivp_desired_heading_ = false;
  clear_has_helm_ivp_desired_heading();
}
inline bool HelmIVPStatus::helm_ivp_desired_heading() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.HelmIVPStatus.helm_ivp_desired_heading)
  return helm_ivp_desired_heading_;
}
inline void HelmIVPStatus::set_helm_ivp_desired_heading(bool value) {
  set_has_helm_ivp_desired_heading();
  helm_ivp_desired_heading_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.HelmIVPStatus.helm_ivp_desired_heading)
}
 
// optional bool helm_ivp_desired_depth = 4 [default = false];
inline bool HelmIVPStatus::has_helm_ivp_desired_depth() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void HelmIVPStatus::set_has_helm_ivp_desired_depth() {
  _has_bits_[0] |= 0x00000008u;
}
inline void HelmIVPStatus::clear_has_helm_ivp_desired_depth() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void HelmIVPStatus::clear_helm_ivp_desired_depth() {
  helm_ivp_desired_depth_ = false;
  clear_has_helm_ivp_desired_depth();
}
inline bool HelmIVPStatus::helm_ivp_desired_depth() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.HelmIVPStatus.helm_ivp_desired_depth)
  return helm_ivp_desired_depth_;
}
inline void HelmIVPStatus::set_helm_ivp_desired_depth(bool value) {
  set_has_helm_ivp_desired_depth();
  helm_ivp_desired_depth_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.HelmIVPStatus.helm_ivp_desired_depth)
}
 
// optional bool helm_ivp_data = 5 [default = false];
inline bool HelmIVPStatus::has_helm_ivp_data() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void HelmIVPStatus::set_has_helm_ivp_data() {
  _has_bits_[0] |= 0x00000010u;
}
inline void HelmIVPStatus::clear_has_helm_ivp_data() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void HelmIVPStatus::clear_helm_ivp_data() {
  helm_ivp_data_ = false;
  clear_has_helm_ivp_data();
}
inline bool HelmIVPStatus::helm_ivp_data() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.HelmIVPStatus.helm_ivp_data)
  return helm_ivp_data_;
}
inline void HelmIVPStatus::set_helm_ivp_data(bool value) {
  set_has_helm_ivp_data();
  helm_ivp_data_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.HelmIVPStatus.helm_ivp_data)
}
 
// -------------------------------------------------------------------
 
// ThreadHealth
 
// repeated .jaiabot.protobuf.Error error = 1;
inline int ThreadHealth::error_size() const {
  return error_.size();
}
inline void ThreadHealth::clear_error() {
  error_.Clear();
}
inline ::jaiabot::protobuf::Error ThreadHealth::error(int index) const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.ThreadHealth.error)
  return static_cast< ::jaiabot::protobuf::Error >(error_.Get(index));
}
inline void ThreadHealth::set_error(int index, ::jaiabot::protobuf::Error value) {
  assert(::jaiabot::protobuf::Error_IsValid(value));
  error_.Set(index, value);
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.ThreadHealth.error)
}
inline void ThreadHealth::add_error(::jaiabot::protobuf::Error value) {
  assert(::jaiabot::protobuf::Error_IsValid(value));
  error_.Add(value);
  // @@protoc_insertion_point(field_add:jaiabot.protobuf.ThreadHealth.error)
}
inline const ::google::protobuf::RepeatedField<int>&
ThreadHealth::error() const {
  // @@protoc_insertion_point(field_list:jaiabot.protobuf.ThreadHealth.error)
  return error_;
}
inline ::google::protobuf::RepeatedField<int>*
ThreadHealth::mutable_error() {
  // @@protoc_insertion_point(field_mutable_list:jaiabot.protobuf.ThreadHealth.error)
  return &error_;
}
 
// repeated .jaiabot.protobuf.Warning warning = 2;
inline int ThreadHealth::warning_size() const {
  return warning_.size();
}
inline void ThreadHealth::clear_warning() {
  warning_.Clear();
}
inline ::jaiabot::protobuf::Warning ThreadHealth::warning(int index) const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.ThreadHealth.warning)
  return static_cast< ::jaiabot::protobuf::Warning >(warning_.Get(index));
}
inline void ThreadHealth::set_warning(int index, ::jaiabot::protobuf::Warning value) {
  assert(::jaiabot::protobuf::Warning_IsValid(value));
  warning_.Set(index, value);
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.ThreadHealth.warning)
}
inline void ThreadHealth::add_warning(::jaiabot::protobuf::Warning value) {
  assert(::jaiabot::protobuf::Warning_IsValid(value));
  warning_.Add(value);
  // @@protoc_insertion_point(field_add:jaiabot.protobuf.ThreadHealth.warning)
}
inline const ::google::protobuf::RepeatedField<int>&
ThreadHealth::warning() const {
  // @@protoc_insertion_point(field_list:jaiabot.protobuf.ThreadHealth.warning)
  return warning_;
}
inline ::google::protobuf::RepeatedField<int>*
ThreadHealth::mutable_warning() {
  // @@protoc_insertion_point(field_mutable_list:jaiabot.protobuf.ThreadHealth.warning)
  return &warning_;
}
 
// -------------------------------------------------------------------
 
// VehicleHealth
 
// -------------------------------------------------------------------
 
// SystemdStartReport
 
// required .jaiabot.protobuf.Error clear_error = 1;
inline bool SystemdStartReport::has_clear_error() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SystemdStartReport::set_has_clear_error() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SystemdStartReport::clear_has_clear_error() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SystemdStartReport::clear_clear_error() {
  clear_error_ = 0;
  clear_has_clear_error();
}
inline ::jaiabot::protobuf::Error SystemdStartReport::clear_error() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.SystemdStartReport.clear_error)
  return static_cast< ::jaiabot::protobuf::Error >(clear_error_);
}
inline void SystemdStartReport::set_clear_error(::jaiabot::protobuf::Error value) {
  assert(::jaiabot::protobuf::Error_IsValid(value));
  set_has_clear_error();
  clear_error_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.SystemdStartReport.clear_error)
}
 
// -------------------------------------------------------------------
 
// SystemdStopReport
 
// required .jaiabot.protobuf.SystemdStopReport.ServiceResult result = 1;
inline bool SystemdStopReport::has_result() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SystemdStopReport::set_has_result() {
  _has_bits_[0] |= 0x00000002u;
}
inline void SystemdStopReport::clear_has_result() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void SystemdStopReport::clear_result() {
  result_ = 0;
  clear_has_result();
}
inline ::jaiabot::protobuf::SystemdStopReport_ServiceResult SystemdStopReport::result() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.SystemdStopReport.result)
  return static_cast< ::jaiabot::protobuf::SystemdStopReport_ServiceResult >(result_);
}
inline void SystemdStopReport::set_result(::jaiabot::protobuf::SystemdStopReport_ServiceResult value) {
  assert(::jaiabot::protobuf::SystemdStopReport_ServiceResult_IsValid(value));
  set_has_result();
  result_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.SystemdStopReport.result)
}
 
// required .jaiabot.protobuf.Error error = 2;
inline bool SystemdStopReport::has_error() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void SystemdStopReport::set_has_error() {
  _has_bits_[0] |= 0x00000004u;
}
inline void SystemdStopReport::clear_has_error() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void SystemdStopReport::clear_error() {
  error_ = 0;
  clear_has_error();
}
inline ::jaiabot::protobuf::Error SystemdStopReport::error() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.SystemdStopReport.error)
  return static_cast< ::jaiabot::protobuf::Error >(error_);
}
inline void SystemdStopReport::set_error(::jaiabot::protobuf::Error value) {
  assert(::jaiabot::protobuf::Error_IsValid(value));
  set_has_error();
  error_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.SystemdStopReport.error)
}
 
// optional string journal_dump_file = 3;
inline bool SystemdStopReport::has_journal_dump_file() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SystemdStopReport::set_has_journal_dump_file() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SystemdStopReport::clear_has_journal_dump_file() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SystemdStopReport::clear_journal_dump_file() {
  journal_dump_file_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_journal_dump_file();
}
inline const ::std::string& SystemdStopReport::journal_dump_file() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.SystemdStopReport.journal_dump_file)
  return journal_dump_file_.GetNoArena();
}
inline void SystemdStopReport::set_journal_dump_file(const ::std::string& value) {
  set_has_journal_dump_file();
  journal_dump_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.SystemdStopReport.journal_dump_file)
}
#if LANG_CXX11
inline void SystemdStopReport::set_journal_dump_file(::std::string&& value) {
  set_has_journal_dump_file();
  journal_dump_file_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:jaiabot.protobuf.SystemdStopReport.journal_dump_file)
}
#endif
inline void SystemdStopReport::set_journal_dump_file(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_journal_dump_file();
  journal_dump_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:jaiabot.protobuf.SystemdStopReport.journal_dump_file)
}
inline void SystemdStopReport::set_journal_dump_file(const char* value, size_t size) {
  set_has_journal_dump_file();
  journal_dump_file_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:jaiabot.protobuf.SystemdStopReport.journal_dump_file)
}
inline ::std::string* SystemdStopReport::mutable_journal_dump_file() {
  set_has_journal_dump_file();
  // @@protoc_insertion_point(field_mutable:jaiabot.protobuf.SystemdStopReport.journal_dump_file)
  return journal_dump_file_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SystemdStopReport::release_journal_dump_file() {
  // @@protoc_insertion_point(field_release:jaiabot.protobuf.SystemdStopReport.journal_dump_file)
  if (!has_journal_dump_file()) {
    return NULL;
  }
  clear_has_journal_dump_file();
  return journal_dump_file_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SystemdStopReport::set_allocated_journal_dump_file(::std::string* journal_dump_file) {
  if (journal_dump_file != NULL) {
    set_has_journal_dump_file();
  } else {
    clear_has_journal_dump_file();
  }
  journal_dump_file_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), journal_dump_file);
  // @@protoc_insertion_point(field_set_allocated:jaiabot.protobuf.SystemdStopReport.journal_dump_file)
}
 
// -------------------------------------------------------------------
 
// SystemdReportAck
 
// required .jaiabot.protobuf.Error error_ack = 1;
inline bool SystemdReportAck::has_error_ack() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SystemdReportAck::set_has_error_ack() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SystemdReportAck::clear_has_error_ack() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SystemdReportAck::clear_error_ack() {
  error_ack_ = 0;
  clear_has_error_ack();
}
inline ::jaiabot::protobuf::Error SystemdReportAck::error_ack() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.SystemdReportAck.error_ack)
  return static_cast< ::jaiabot::protobuf::Error >(error_ack_);
}
inline void SystemdReportAck::set_error_ack(::jaiabot::protobuf::Error value) {
  assert(::jaiabot::protobuf::Error_IsValid(value));
  set_has_error_ack();
  error_ack_ = value;
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.SystemdReportAck.error_ack)
}
 
#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
 
// @@protoc_insertion_point(namespace_scope)
 
}  // namespace protobuf
}  // namespace jaiabot
 
namespace google {
namespace protobuf {
 
template <> struct is_proto_enum< ::jaiabot::protobuf::NTPStatus_NTPPeer_TallyCode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::jaiabot::protobuf::NTPStatus_NTPPeer_TallyCode>() {
  return ::jaiabot::protobuf::NTPStatus_NTPPeer_TallyCode_descriptor();
}
template <> struct is_proto_enum< ::jaiabot::protobuf::NTPStatus_SyncSource> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::jaiabot::protobuf::NTPStatus_SyncSource>() {
  return ::jaiabot::protobuf::NTPStatus_SyncSource_descriptor();
}
template <> struct is_proto_enum< ::jaiabot::protobuf::NTPStatus_LeapIndicator> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::jaiabot::protobuf::NTPStatus_LeapIndicator>() {
  return ::jaiabot::protobuf::NTPStatus_LeapIndicator_descriptor();
}
template <> struct is_proto_enum< ::jaiabot::protobuf::NTPStatus_NTPSystemEvent> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::jaiabot::protobuf::NTPStatus_NTPSystemEvent>() {
  return ::jaiabot::protobuf::NTPStatus_NTPSystemEvent_descriptor();
}
template <> struct is_proto_enum< ::jaiabot::protobuf::SystemdStopReport_ServiceResult> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::jaiabot::protobuf::SystemdStopReport_ServiceResult>() {
  return ::jaiabot::protobuf::SystemdStopReport_ServiceResult_descriptor();
}
template <> struct is_proto_enum< ::jaiabot::protobuf::Error> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::jaiabot::protobuf::Error>() {
  return ::jaiabot::protobuf::Error_descriptor();
}
template <> struct is_proto_enum< ::jaiabot::protobuf::Warning> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::jaiabot::protobuf::Warning>() {
  return ::jaiabot::protobuf::Warning_descriptor();
}
 
}  // namespace protobuf
}  // namespace google
 
// @@protoc_insertion_point(global_scope)
 
#endif  // PROTOBUF_INCLUDED_jaiabot_2fmessages_2fhealth_2eproto