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 GOOGLE_PROTOBUF_INCLUDED_jaiabot_2fmessages_2fhealth_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_jaiabot_2fmessages_2fhealth_2eproto
 
#include <limits>
#include <string>
 
#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#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 3021012 < 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/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_bases.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.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)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_jaiabot_2fmessages_2fhealth_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE
 
// Internal implementation detail -- do not use these members.
struct TableStruct_jaiabot_2fmessages_2fhealth_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_jaiabot_2fmessages_2fhealth_2eproto;
namespace jaiabot {
namespace protobuf {
class HelmIVPStatus;
struct HelmIVPStatusDefaultTypeInternal;
extern HelmIVPStatusDefaultTypeInternal _HelmIVPStatus_default_instance_;
class LinuxHardwareStatus;
struct LinuxHardwareStatusDefaultTypeInternal;
extern LinuxHardwareStatusDefaultTypeInternal _LinuxHardwareStatus_default_instance_;
class LinuxHardwareStatus_Disk;
struct LinuxHardwareStatus_DiskDefaultTypeInternal;
extern LinuxHardwareStatus_DiskDefaultTypeInternal _LinuxHardwareStatus_Disk_default_instance_;
class LinuxHardwareStatus_Information;
struct LinuxHardwareStatus_InformationDefaultTypeInternal;
extern LinuxHardwareStatus_InformationDefaultTypeInternal _LinuxHardwareStatus_Information_default_instance_;
class LinuxHardwareStatus_Memory;
struct LinuxHardwareStatus_MemoryDefaultTypeInternal;
extern LinuxHardwareStatus_MemoryDefaultTypeInternal _LinuxHardwareStatus_Memory_default_instance_;
class LinuxHardwareStatus_Processor;
struct LinuxHardwareStatus_ProcessorDefaultTypeInternal;
extern LinuxHardwareStatus_ProcessorDefaultTypeInternal _LinuxHardwareStatus_Processor_default_instance_;
class LinuxHardwareStatus_Processor_LoadAverages;
struct LinuxHardwareStatus_Processor_LoadAveragesDefaultTypeInternal;
extern LinuxHardwareStatus_Processor_LoadAveragesDefaultTypeInternal _LinuxHardwareStatus_Processor_LoadAverages_default_instance_;
class LinuxHardwareStatus_WiFi;
struct LinuxHardwareStatus_WiFiDefaultTypeInternal;
extern LinuxHardwareStatus_WiFiDefaultTypeInternal _LinuxHardwareStatus_WiFi_default_instance_;
class NTPStatus;
struct NTPStatusDefaultTypeInternal;
extern NTPStatusDefaultTypeInternal _NTPStatus_default_instance_;
class NTPStatus_NTPPeer;
struct NTPStatus_NTPPeerDefaultTypeInternal;
extern NTPStatus_NTPPeerDefaultTypeInternal _NTPStatus_NTPPeer_default_instance_;
class SystemdReportAck;
struct SystemdReportAckDefaultTypeInternal;
extern SystemdReportAckDefaultTypeInternal _SystemdReportAck_default_instance_;
class SystemdStartReport;
struct SystemdStartReportDefaultTypeInternal;
extern SystemdStartReportDefaultTypeInternal _SystemdStartReport_default_instance_;
class SystemdStopReport;
struct SystemdStopReportDefaultTypeInternal;
extern SystemdStopReportDefaultTypeInternal _SystemdStopReport_default_instance_;
class ThreadHealth;
struct ThreadHealthDefaultTypeInternal;
extern ThreadHealthDefaultTypeInternal _ThreadHealth_default_instance_;
class VehicleHealth;
struct VehicleHealthDefaultTypeInternal;
extern VehicleHealthDefaultTypeInternal _VehicleHealth_default_instance_;
}  // namespace protobuf
}  // namespace jaiabot
PROTOBUF_NAMESPACE_OPEN
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*);
PROTOBUF_NAMESPACE_CLOSE
namespace jaiabot {
namespace protobuf {
 
enum NTPStatus_NTPPeer_TallyCode : int {
  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);
constexpr NTPStatus_NTPPeer_TallyCode NTPStatus_NTPPeer_TallyCode_TallyCode_MIN = NTPStatus_NTPPeer_TallyCode_PEER_CODE_UNKNOWN;
constexpr NTPStatus_NTPPeer_TallyCode NTPStatus_NTPPeer_TallyCode_TallyCode_MAX = NTPStatus_NTPPeer_TallyCode_PEER_DISCARDED_BY_INTERSECTION;
constexpr int NTPStatus_NTPPeer_TallyCode_TallyCode_ARRAYSIZE = NTPStatus_NTPPeer_TallyCode_TallyCode_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* NTPStatus_NTPPeer_TallyCode_descriptor();
template<typename T>
inline const std::string& NTPStatus_NTPPeer_TallyCode_Name(T enum_t_value) {
  static_assert(::std::is_same<T, NTPStatus_NTPPeer_TallyCode>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function NTPStatus_NTPPeer_TallyCode_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    NTPStatus_NTPPeer_TallyCode_descriptor(), enum_t_value);
}
inline bool NTPStatus_NTPPeer_TallyCode_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, NTPStatus_NTPPeer_TallyCode* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<NTPStatus_NTPPeer_TallyCode>(
    NTPStatus_NTPPeer_TallyCode_descriptor(), name, value);
}
enum NTPStatus_SyncSource : int {
  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);
constexpr NTPStatus_SyncSource NTPStatus_SyncSource_SyncSource_MIN = NTPStatus_SyncSource_SYNC_UNKNOWN;
constexpr NTPStatus_SyncSource NTPStatus_SyncSource_SyncSource_MAX = NTPStatus_SyncSource_SYNC_TELEPHONE;
constexpr int NTPStatus_SyncSource_SyncSource_ARRAYSIZE = NTPStatus_SyncSource_SyncSource_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* NTPStatus_SyncSource_descriptor();
template<typename T>
inline const std::string& NTPStatus_SyncSource_Name(T enum_t_value) {
  static_assert(::std::is_same<T, NTPStatus_SyncSource>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function NTPStatus_SyncSource_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    NTPStatus_SyncSource_descriptor(), enum_t_value);
}
inline bool NTPStatus_SyncSource_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, NTPStatus_SyncSource* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<NTPStatus_SyncSource>(
    NTPStatus_SyncSource_descriptor(), name, value);
}
enum NTPStatus_LeapIndicator : int {
  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);
constexpr NTPStatus_LeapIndicator NTPStatus_LeapIndicator_LeapIndicator_MIN = NTPStatus_LeapIndicator_LEAP_UNKNOWN;
constexpr NTPStatus_LeapIndicator NTPStatus_LeapIndicator_LeapIndicator_MAX = NTPStatus_LeapIndicator_LEAP_CLOCK_NOT_SYNCHRONIZED;
constexpr int NTPStatus_LeapIndicator_LeapIndicator_ARRAYSIZE = NTPStatus_LeapIndicator_LeapIndicator_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* NTPStatus_LeapIndicator_descriptor();
template<typename T>
inline const std::string& NTPStatus_LeapIndicator_Name(T enum_t_value) {
  static_assert(::std::is_same<T, NTPStatus_LeapIndicator>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function NTPStatus_LeapIndicator_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    NTPStatus_LeapIndicator_descriptor(), enum_t_value);
}
inline bool NTPStatus_LeapIndicator_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, NTPStatus_LeapIndicator* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<NTPStatus_LeapIndicator>(
    NTPStatus_LeapIndicator_descriptor(), name, value);
}
enum NTPStatus_NTPSystemEvent : int {
  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);
constexpr NTPStatus_NTPSystemEvent NTPStatus_NTPSystemEvent_NTPSystemEvent_MIN = NTPStatus_NTPSystemEvent_NTP_SYSTEM_EVENT_UNKNOWN;
constexpr NTPStatus_NTPSystemEvent NTPStatus_NTPSystemEvent_NTPSystemEvent_MAX = NTPStatus_NTPSystemEvent_NTP_SYSTEM_STALE_LEAPSECOND_VALUES;
constexpr int NTPStatus_NTPSystemEvent_NTPSystemEvent_ARRAYSIZE = NTPStatus_NTPSystemEvent_NTPSystemEvent_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* NTPStatus_NTPSystemEvent_descriptor();
template<typename T>
inline const std::string& NTPStatus_NTPSystemEvent_Name(T enum_t_value) {
  static_assert(::std::is_same<T, NTPStatus_NTPSystemEvent>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function NTPStatus_NTPSystemEvent_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    NTPStatus_NTPSystemEvent_descriptor(), enum_t_value);
}
inline bool NTPStatus_NTPSystemEvent_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, NTPStatus_NTPSystemEvent* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<NTPStatus_NTPSystemEvent>(
    NTPStatus_NTPSystemEvent_descriptor(), name, value);
}
enum SystemdStopReport_ServiceResult : int {
  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);
constexpr SystemdStopReport_ServiceResult SystemdStopReport_ServiceResult_ServiceResult_MIN = SystemdStopReport_ServiceResult_SERVICE_RESULT_UNKNOWN;
constexpr SystemdStopReport_ServiceResult SystemdStopReport_ServiceResult_ServiceResult_MAX = SystemdStopReport_ServiceResult_SERVICE_RESULT_RESOURCES;
constexpr int SystemdStopReport_ServiceResult_ServiceResult_ARRAYSIZE = SystemdStopReport_ServiceResult_ServiceResult_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SystemdStopReport_ServiceResult_descriptor();
template<typename T>
inline const std::string& SystemdStopReport_ServiceResult_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SystemdStopReport_ServiceResult>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SystemdStopReport_ServiceResult_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SystemdStopReport_ServiceResult_descriptor(), enum_t_value);
}
inline bool SystemdStopReport_ServiceResult_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemdStopReport_ServiceResult* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SystemdStopReport_ServiceResult>(
    SystemdStopReport_ServiceResult_descriptor(), name, value);
}
enum Error : int {
  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__FAILED__JAIABOT_SENSORS = 40,
  ERROR__FAILED__JAIABOT_COMMS_MANAGER = 41,
  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__NOT_RESPONDING__JAIABOT_DRIVER_CAMERA = 126,
  ERROR__NOT_RESPONDING__JAIABOT_COMMS_MANAGER = 127,
  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,
  ERROR__INIT_FAILED__BLUE_ROBOTICS__BAR30 = 800,
  ERROR__MISSING_DATA__BLUEROBOTICS_BAR30_DATA = 801
};
bool Error_IsValid(int value);
constexpr Error Error_MIN = ERROR__TOO_MANY_ERRORS_TO_REPORT_ALL;
constexpr Error Error_MAX = ERROR__MISSING_DATA__BLUEROBOTICS_BAR30_DATA;
constexpr int Error_ARRAYSIZE = Error_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Error_descriptor();
template<typename T>
inline const std::string& Error_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Error>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Error_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Error_descriptor(), enum_t_value);
}
inline bool Error_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Error* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Error>(
    Error_descriptor(), name, value);
}
enum Warning : int {
  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,
  WARNING__INIT_FAILED__ATLAS_SCIENTIFIC__OEM_DO = 800,
  WARNING__INIT_FAILED__ATLAS_SCIENTIFIC__OEM_EC = 801,
  WARNING__INIT_FAILED__ATLAS_SCIENTIFIC__OEM_PH = 802,
  WARNING__INIT_FAILED__TURNER__C_FLUOR = 803,
  WARNING__MISSING_DATA__ATLAS_OEM_EC_DATA = 804,
  WARNING__MISSING_DATA__ATLAS_OEM_PH_DATA = 805,
  WARNING__MISSING_DATA__ATLAS_OEM_DO_DATA = 806,
  WARNING__MISSING_DATA__TURNER_C_FLUOR_DATA = 807
};
bool Warning_IsValid(int value);
constexpr Warning Warning_MIN = WARNING__TOO_MANY_WARNINGS_TO_REPORT_ALL;
constexpr Warning Warning_MAX = WARNING__MISSING_DATA__TURNER_C_FLUOR_DATA;
constexpr int Warning_ARRAYSIZE = Warning_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Warning_descriptor();
template<typename T>
inline const std::string& Warning_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Warning>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Warning_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Warning_descriptor(), enum_t_value);
}
inline bool Warning_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Warning* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Warning>(
    Warning_descriptor(), name, value);
}
// ===================================================================
 
class LinuxHardwareStatus_Processor_LoadAverages final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:jaiabot.protobuf.LinuxHardwareStatus.Processor.LoadAverages) */ {
 public:
  inline LinuxHardwareStatus_Processor_LoadAverages() : LinuxHardwareStatus_Processor_LoadAverages(nullptr) {}
  ~LinuxHardwareStatus_Processor_LoadAverages() override;
  explicit PROTOBUF_CONSTEXPR LinuxHardwareStatus_Processor_LoadAverages(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  LinuxHardwareStatus_Processor_LoadAverages(const LinuxHardwareStatus_Processor_LoadAverages& from);
  LinuxHardwareStatus_Processor_LoadAverages(LinuxHardwareStatus_Processor_LoadAverages&& from) noexcept
    : LinuxHardwareStatus_Processor_LoadAverages() {
    *this = ::std::move(from);
  }
 
  inline LinuxHardwareStatus_Processor_LoadAverages& operator=(const LinuxHardwareStatus_Processor_LoadAverages& from) {
    CopyFrom(from);
    return *this;
  }
  inline LinuxHardwareStatus_Processor_LoadAverages& operator=(LinuxHardwareStatus_Processor_LoadAverages&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LinuxHardwareStatus_Processor_LoadAverages& default_instance() {
    return *internal_default_instance();
  }
  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;
 
  friend void swap(LinuxHardwareStatus_Processor_LoadAverages& a, LinuxHardwareStatus_Processor_LoadAverages& b) {
    a.Swap(&b);
  }
  inline void Swap(LinuxHardwareStatus_Processor_LoadAverages* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(LinuxHardwareStatus_Processor_LoadAverages* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  LinuxHardwareStatus_Processor_LoadAverages* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LinuxHardwareStatus_Processor_LoadAverages>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LinuxHardwareStatus_Processor_LoadAverages& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const LinuxHardwareStatus_Processor_LoadAverages& from) {
    LinuxHardwareStatus_Processor_LoadAverages::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LinuxHardwareStatus_Processor_LoadAverages* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "jaiabot.protobuf.LinuxHardwareStatus.Processor.LoadAverages";
  }
  protected:
  explicit LinuxHardwareStatus_Processor_LoadAverages(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kOneMinFieldNumber = 1,
    kFiveMinFieldNumber = 2,
    kFifteenMinFieldNumber = 3,
  };
  // required float one_min = 1;
  bool has_one_min() const;
  private:
  bool _internal_has_one_min() const;
  public:
  void clear_one_min();
  float one_min() const;
  void set_one_min(float value);
  private:
  float _internal_one_min() const;
  void _internal_set_one_min(float value);
  public:
 
  // required float five_min = 2;
  bool has_five_min() const;
  private:
  bool _internal_has_five_min() const;
  public:
  void clear_five_min();
  float five_min() const;
  void set_five_min(float value);
  private:
  float _internal_five_min() const;
  void _internal_set_five_min(float value);
  public:
 
  // required float fifteen_min = 3;
  bool has_fifteen_min() const;
  private:
  bool _internal_has_fifteen_min() const;
  public:
  void clear_fifteen_min();
  float fifteen_min() const;
  void set_fifteen_min(float value);
  private:
  float _internal_fifteen_min() const;
  void _internal_set_fifteen_min(float value);
  public:
 
  // @@protoc_insertion_point(class_scope:jaiabot.protobuf.LinuxHardwareStatus.Processor.LoadAverages)
 private:
  class _Internal;
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float one_min_;
    float five_min_;
    float fifteen_min_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_jaiabot_2fmessages_2fhealth_2eproto;
};
// -------------------------------------------------------------------
 
class LinuxHardwareStatus_Processor final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:jaiabot.protobuf.LinuxHardwareStatus.Processor) */ {
 public:
  inline LinuxHardwareStatus_Processor() : LinuxHardwareStatus_Processor(nullptr) {}
  ~LinuxHardwareStatus_Processor() override;
  explicit PROTOBUF_CONSTEXPR LinuxHardwareStatus_Processor(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  LinuxHardwareStatus_Processor(const LinuxHardwareStatus_Processor& from);
  LinuxHardwareStatus_Processor(LinuxHardwareStatus_Processor&& from) noexcept
    : LinuxHardwareStatus_Processor() {
    *this = ::std::move(from);
  }
 
  inline LinuxHardwareStatus_Processor& operator=(const LinuxHardwareStatus_Processor& from) {
    CopyFrom(from);
    return *this;
  }
  inline LinuxHardwareStatus_Processor& operator=(LinuxHardwareStatus_Processor&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LinuxHardwareStatus_Processor& default_instance() {
    return *internal_default_instance();
  }
  static inline const LinuxHardwareStatus_Processor* internal_default_instance() {
    return reinterpret_cast<const LinuxHardwareStatus_Processor*>(
               &_LinuxHardwareStatus_Processor_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;
 
  friend void swap(LinuxHardwareStatus_Processor& a, LinuxHardwareStatus_Processor& b) {
    a.Swap(&b);
  }
  inline void Swap(LinuxHardwareStatus_Processor* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(LinuxHardwareStatus_Processor* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  LinuxHardwareStatus_Processor* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LinuxHardwareStatus_Processor>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LinuxHardwareStatus_Processor& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const LinuxHardwareStatus_Processor& from) {
    LinuxHardwareStatus_Processor::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LinuxHardwareStatus_Processor* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "jaiabot.protobuf.LinuxHardwareStatus.Processor";
  }
  protected:
  explicit LinuxHardwareStatus_Processor(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  typedef LinuxHardwareStatus_Processor_LoadAverages LoadAverages;
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kLoadsFieldNumber = 10,
    kNumProcessesFieldNumber = 15,
    kNumProcessorsFieldNumber = 20,
  };
  // optional .jaiabot.protobuf.LinuxHardwareStatus.Processor.LoadAverages loads = 10;
  bool has_loads() const;
  private:
  bool _internal_has_loads() const;
  public:
  void clear_loads();
  const ::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages& loads() const;
  PROTOBUF_NODISCARD ::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages* release_loads();
  ::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages* mutable_loads();
  void set_allocated_loads(::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages* loads);
  private:
  const ::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages& _internal_loads() const;
  ::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages* _internal_mutable_loads();
  public:
  void unsafe_arena_set_allocated_loads(
      ::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages* loads);
  ::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages* unsafe_arena_release_loads();
 
  // optional int32 num_processes = 15;
  bool has_num_processes() const;
  private:
  bool _internal_has_num_processes() const;
  public:
  void clear_num_processes();
  int32_t num_processes() const;
  void set_num_processes(int32_t value);
  private:
  int32_t _internal_num_processes() const;
  void _internal_set_num_processes(int32_t value);
  public:
 
  // optional int32 num_processors = 20;
  bool has_num_processors() const;
  private:
  bool _internal_has_num_processors() const;
  public:
  void clear_num_processors();
  int32_t num_processors() const;
  void set_num_processors(int32_t value);
  private:
  int32_t _internal_num_processors() const;
  void _internal_set_num_processors(int32_t value);
  public:
 
  // @@protoc_insertion_point(class_scope:jaiabot.protobuf.LinuxHardwareStatus.Processor)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages* loads_;
    int32_t num_processes_;
    int32_t num_processors_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_jaiabot_2fmessages_2fhealth_2eproto;
};
// -------------------------------------------------------------------
 
class LinuxHardwareStatus_Information final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:jaiabot.protobuf.LinuxHardwareStatus.Information) */ {
 public:
  inline LinuxHardwareStatus_Information() : LinuxHardwareStatus_Information(nullptr) {}
  ~LinuxHardwareStatus_Information() override;
  explicit PROTOBUF_CONSTEXPR LinuxHardwareStatus_Information(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  LinuxHardwareStatus_Information(const LinuxHardwareStatus_Information& from);
  LinuxHardwareStatus_Information(LinuxHardwareStatus_Information&& from) noexcept
    : LinuxHardwareStatus_Information() {
    *this = ::std::move(from);
  }
 
  inline LinuxHardwareStatus_Information& operator=(const LinuxHardwareStatus_Information& from) {
    CopyFrom(from);
    return *this;
  }
  inline LinuxHardwareStatus_Information& operator=(LinuxHardwareStatus_Information&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LinuxHardwareStatus_Information& default_instance() {
    return *internal_default_instance();
  }
  static inline const LinuxHardwareStatus_Information* internal_default_instance() {
    return reinterpret_cast<const LinuxHardwareStatus_Information*>(
               &_LinuxHardwareStatus_Information_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;
 
  friend void swap(LinuxHardwareStatus_Information& a, LinuxHardwareStatus_Information& b) {
    a.Swap(&b);
  }
  inline void Swap(LinuxHardwareStatus_Information* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(LinuxHardwareStatus_Information* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  LinuxHardwareStatus_Information* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LinuxHardwareStatus_Information>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LinuxHardwareStatus_Information& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const LinuxHardwareStatus_Information& from) {
    LinuxHardwareStatus_Information::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LinuxHardwareStatus_Information* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "jaiabot.protobuf.LinuxHardwareStatus.Information";
  }
  protected:
  explicit LinuxHardwareStatus_Information(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kTotalFieldNumber = 1,
    kAvailableFieldNumber = 2,
    kUsePercentFieldNumber = 3,
  };
  // required uint64 total = 1 [(.dccl.field) = {
  bool has_total() const;
  private:
  bool _internal_has_total() const;
  public:
  void clear_total();
  uint64_t total() const;
  void set_total(uint64_t value);
  private:
  uint64_t _internal_total() const;
  void _internal_set_total(uint64_t value);
  public:
 
  // required uint64 available = 2 [(.dccl.field) = {
  bool has_available() const;
  private:
  bool _internal_has_available() const;
  public:
  void clear_available();
  uint64_t available() const;
  void set_available(uint64_t value);
  private:
  uint64_t _internal_available() const;
  void _internal_set_available(uint64_t value);
  public:
 
  // required float use_percent = 3;
  bool has_use_percent() const;
  private:
  bool _internal_has_use_percent() const;
  public:
  void clear_use_percent();
  float use_percent() const;
  void set_use_percent(float value);
  private:
  float _internal_use_percent() const;
  void _internal_set_use_percent(float value);
  public:
 
  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:
  class _Internal;
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint64_t total_;
    uint64_t available_;
    float use_percent_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_jaiabot_2fmessages_2fhealth_2eproto;
};
// -------------------------------------------------------------------
 
class LinuxHardwareStatus_Memory final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:jaiabot.protobuf.LinuxHardwareStatus.Memory) */ {
 public:
  inline LinuxHardwareStatus_Memory() : LinuxHardwareStatus_Memory(nullptr) {}
  ~LinuxHardwareStatus_Memory() override;
  explicit PROTOBUF_CONSTEXPR LinuxHardwareStatus_Memory(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  LinuxHardwareStatus_Memory(const LinuxHardwareStatus_Memory& from);
  LinuxHardwareStatus_Memory(LinuxHardwareStatus_Memory&& from) noexcept
    : LinuxHardwareStatus_Memory() {
    *this = ::std::move(from);
  }
 
  inline LinuxHardwareStatus_Memory& operator=(const LinuxHardwareStatus_Memory& from) {
    CopyFrom(from);
    return *this;
  }
  inline LinuxHardwareStatus_Memory& operator=(LinuxHardwareStatus_Memory&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LinuxHardwareStatus_Memory& default_instance() {
    return *internal_default_instance();
  }
  static inline const LinuxHardwareStatus_Memory* internal_default_instance() {
    return reinterpret_cast<const LinuxHardwareStatus_Memory*>(
               &_LinuxHardwareStatus_Memory_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;
 
  friend void swap(LinuxHardwareStatus_Memory& a, LinuxHardwareStatus_Memory& b) {
    a.Swap(&b);
  }
  inline void Swap(LinuxHardwareStatus_Memory* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(LinuxHardwareStatus_Memory* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  LinuxHardwareStatus_Memory* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LinuxHardwareStatus_Memory>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LinuxHardwareStatus_Memory& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const LinuxHardwareStatus_Memory& from) {
    LinuxHardwareStatus_Memory::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LinuxHardwareStatus_Memory* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "jaiabot.protobuf.LinuxHardwareStatus.Memory";
  }
  protected:
  explicit LinuxHardwareStatus_Memory(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kRamFieldNumber = 1,
    kSwapFieldNumber = 2,
  };
  // required .jaiabot.protobuf.LinuxHardwareStatus.Information ram = 1;
  bool has_ram() const;
  private:
  bool _internal_has_ram() const;
  public:
  void clear_ram();
  const ::jaiabot::protobuf::LinuxHardwareStatus_Information& ram() const;
  PROTOBUF_NODISCARD ::jaiabot::protobuf::LinuxHardwareStatus_Information* release_ram();
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* mutable_ram();
  void set_allocated_ram(::jaiabot::protobuf::LinuxHardwareStatus_Information* ram);
  private:
  const ::jaiabot::protobuf::LinuxHardwareStatus_Information& _internal_ram() const;
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* _internal_mutable_ram();
  public:
  void unsafe_arena_set_allocated_ram(
      ::jaiabot::protobuf::LinuxHardwareStatus_Information* ram);
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* unsafe_arena_release_ram();
 
  // required .jaiabot.protobuf.LinuxHardwareStatus.Information swap = 2;
  bool has_swap() const;
  private:
  bool _internal_has_swap() const;
  public:
  void clear_swap();
  const ::jaiabot::protobuf::LinuxHardwareStatus_Information& swap() const;
  PROTOBUF_NODISCARD ::jaiabot::protobuf::LinuxHardwareStatus_Information* release_swap();
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* mutable_swap();
  void set_allocated_swap(::jaiabot::protobuf::LinuxHardwareStatus_Information* swap);
  private:
  const ::jaiabot::protobuf::LinuxHardwareStatus_Information& _internal_swap() const;
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* _internal_mutable_swap();
  public:
  void unsafe_arena_set_allocated_swap(
      ::jaiabot::protobuf::LinuxHardwareStatus_Information* swap);
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* unsafe_arena_release_swap();
 
  // @@protoc_insertion_point(class_scope:jaiabot.protobuf.LinuxHardwareStatus.Memory)
 private:
  class _Internal;
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::jaiabot::protobuf::LinuxHardwareStatus_Information* ram_;
    ::jaiabot::protobuf::LinuxHardwareStatus_Information* swap_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_jaiabot_2fmessages_2fhealth_2eproto;
};
// -------------------------------------------------------------------
 
class LinuxHardwareStatus_Disk final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:jaiabot.protobuf.LinuxHardwareStatus.Disk) */ {
 public:
  inline LinuxHardwareStatus_Disk() : LinuxHardwareStatus_Disk(nullptr) {}
  ~LinuxHardwareStatus_Disk() override;
  explicit PROTOBUF_CONSTEXPR LinuxHardwareStatus_Disk(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  LinuxHardwareStatus_Disk(const LinuxHardwareStatus_Disk& from);
  LinuxHardwareStatus_Disk(LinuxHardwareStatus_Disk&& from) noexcept
    : LinuxHardwareStatus_Disk() {
    *this = ::std::move(from);
  }
 
  inline LinuxHardwareStatus_Disk& operator=(const LinuxHardwareStatus_Disk& from) {
    CopyFrom(from);
    return *this;
  }
  inline LinuxHardwareStatus_Disk& operator=(LinuxHardwareStatus_Disk&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LinuxHardwareStatus_Disk& default_instance() {
    return *internal_default_instance();
  }
  static inline const LinuxHardwareStatus_Disk* internal_default_instance() {
    return reinterpret_cast<const LinuxHardwareStatus_Disk*>(
               &_LinuxHardwareStatus_Disk_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;
 
  friend void swap(LinuxHardwareStatus_Disk& a, LinuxHardwareStatus_Disk& b) {
    a.Swap(&b);
  }
  inline void Swap(LinuxHardwareStatus_Disk* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(LinuxHardwareStatus_Disk* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  LinuxHardwareStatus_Disk* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LinuxHardwareStatus_Disk>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LinuxHardwareStatus_Disk& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const LinuxHardwareStatus_Disk& from) {
    LinuxHardwareStatus_Disk::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LinuxHardwareStatus_Disk* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "jaiabot.protobuf.LinuxHardwareStatus.Disk";
  }
  protected:
  explicit LinuxHardwareStatus_Disk(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kRootfsFieldNumber = 1,
    kDataFieldNumber = 2,
  };
  // optional .jaiabot.protobuf.LinuxHardwareStatus.Information rootfs = 1;
  bool has_rootfs() const;
  private:
  bool _internal_has_rootfs() const;
  public:
  void clear_rootfs();
  const ::jaiabot::protobuf::LinuxHardwareStatus_Information& rootfs() const;
  PROTOBUF_NODISCARD ::jaiabot::protobuf::LinuxHardwareStatus_Information* release_rootfs();
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* mutable_rootfs();
  void set_allocated_rootfs(::jaiabot::protobuf::LinuxHardwareStatus_Information* rootfs);
  private:
  const ::jaiabot::protobuf::LinuxHardwareStatus_Information& _internal_rootfs() const;
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* _internal_mutable_rootfs();
  public:
  void unsafe_arena_set_allocated_rootfs(
      ::jaiabot::protobuf::LinuxHardwareStatus_Information* rootfs);
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* unsafe_arena_release_rootfs();
 
  // optional .jaiabot.protobuf.LinuxHardwareStatus.Information data = 2;
  bool has_data() const;
  private:
  bool _internal_has_data() const;
  public:
  void clear_data();
  const ::jaiabot::protobuf::LinuxHardwareStatus_Information& data() const;
  PROTOBUF_NODISCARD ::jaiabot::protobuf::LinuxHardwareStatus_Information* release_data();
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* mutable_data();
  void set_allocated_data(::jaiabot::protobuf::LinuxHardwareStatus_Information* data);
  private:
  const ::jaiabot::protobuf::LinuxHardwareStatus_Information& _internal_data() const;
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* _internal_mutable_data();
  public:
  void unsafe_arena_set_allocated_data(
      ::jaiabot::protobuf::LinuxHardwareStatus_Information* data);
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* unsafe_arena_release_data();
 
  // @@protoc_insertion_point(class_scope:jaiabot.protobuf.LinuxHardwareStatus.Disk)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::jaiabot::protobuf::LinuxHardwareStatus_Information* rootfs_;
    ::jaiabot::protobuf::LinuxHardwareStatus_Information* data_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_jaiabot_2fmessages_2fhealth_2eproto;
};
// -------------------------------------------------------------------
 
class LinuxHardwareStatus_WiFi final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:jaiabot.protobuf.LinuxHardwareStatus.WiFi) */ {
 public:
  inline LinuxHardwareStatus_WiFi() : LinuxHardwareStatus_WiFi(nullptr) {}
  ~LinuxHardwareStatus_WiFi() override;
  explicit PROTOBUF_CONSTEXPR LinuxHardwareStatus_WiFi(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  LinuxHardwareStatus_WiFi(const LinuxHardwareStatus_WiFi& from);
  LinuxHardwareStatus_WiFi(LinuxHardwareStatus_WiFi&& from) noexcept
    : LinuxHardwareStatus_WiFi() {
    *this = ::std::move(from);
  }
 
  inline LinuxHardwareStatus_WiFi& operator=(const LinuxHardwareStatus_WiFi& from) {
    CopyFrom(from);
    return *this;
  }
  inline LinuxHardwareStatus_WiFi& operator=(LinuxHardwareStatus_WiFi&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LinuxHardwareStatus_WiFi& default_instance() {
    return *internal_default_instance();
  }
  static inline const LinuxHardwareStatus_WiFi* internal_default_instance() {
    return reinterpret_cast<const LinuxHardwareStatus_WiFi*>(
               &_LinuxHardwareStatus_WiFi_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;
 
  friend void swap(LinuxHardwareStatus_WiFi& a, LinuxHardwareStatus_WiFi& b) {
    a.Swap(&b);
  }
  inline void Swap(LinuxHardwareStatus_WiFi* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(LinuxHardwareStatus_WiFi* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  LinuxHardwareStatus_WiFi* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LinuxHardwareStatus_WiFi>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LinuxHardwareStatus_WiFi& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const LinuxHardwareStatus_WiFi& from) {
    LinuxHardwareStatus_WiFi::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LinuxHardwareStatus_WiFi* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "jaiabot.protobuf.LinuxHardwareStatus.WiFi";
  }
  protected:
  explicit LinuxHardwareStatus_WiFi(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kIsConnectedFieldNumber = 1,
    kLinkQualityFieldNumber = 2,
    kLinkQualityPercentageFieldNumber = 3,
    kSignalLevelFieldNumber = 4,
    kNoiseLevelFieldNumber = 5,
  };
  // required bool is_connected = 1;
  bool has_is_connected() const;
  private:
  bool _internal_has_is_connected() const;
  public:
  void clear_is_connected();
  bool is_connected() const;
  void set_is_connected(bool value);
  private:
  bool _internal_is_connected() const;
  void _internal_set_is_connected(bool value);
  public:
 
  // optional uint32 link_quality = 2;
  bool has_link_quality() const;
  private:
  bool _internal_has_link_quality() const;
  public:
  void clear_link_quality();
  uint32_t link_quality() const;
  void set_link_quality(uint32_t value);
  private:
  uint32_t _internal_link_quality() const;
  void _internal_set_link_quality(uint32_t value);
  public:
 
  // optional uint32 link_quality_percentage = 3;
  bool has_link_quality_percentage() const;
  private:
  bool _internal_has_link_quality_percentage() const;
  public:
  void clear_link_quality_percentage();
  uint32_t link_quality_percentage() const;
  void set_link_quality_percentage(uint32_t value);
  private:
  uint32_t _internal_link_quality_percentage() const;
  void _internal_set_link_quality_percentage(uint32_t value);
  public:
 
  // optional int32 signal_level = 4;
  bool has_signal_level() const;
  private:
  bool _internal_has_signal_level() const;
  public:
  void clear_signal_level();
  int32_t signal_level() const;
  void set_signal_level(int32_t value);
  private:
  int32_t _internal_signal_level() const;
  void _internal_set_signal_level(int32_t value);
  public:
 
  // optional int32 noise_level = 5;
  bool has_noise_level() const;
  private:
  bool _internal_has_noise_level() const;
  public:
  void clear_noise_level();
  int32_t noise_level() const;
  void set_noise_level(int32_t value);
  private:
  int32_t _internal_noise_level() const;
  void _internal_set_noise_level(int32_t value);
  public:
 
  // @@protoc_insertion_point(class_scope:jaiabot.protobuf.LinuxHardwareStatus.WiFi)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    bool is_connected_;
    uint32_t link_quality_;
    uint32_t link_quality_percentage_;
    int32_t signal_level_;
    int32_t noise_level_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_jaiabot_2fmessages_2fhealth_2eproto;
};
// -------------------------------------------------------------------
 
class LinuxHardwareStatus final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:jaiabot.protobuf.LinuxHardwareStatus) */ {
 public:
  inline LinuxHardwareStatus() : LinuxHardwareStatus(nullptr) {}
  ~LinuxHardwareStatus() override;
  explicit PROTOBUF_CONSTEXPR LinuxHardwareStatus(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  LinuxHardwareStatus(const LinuxHardwareStatus& from);
  LinuxHardwareStatus(LinuxHardwareStatus&& from) noexcept
    : LinuxHardwareStatus() {
    *this = ::std::move(from);
  }
 
  inline LinuxHardwareStatus& operator=(const LinuxHardwareStatus& from) {
    CopyFrom(from);
    return *this;
  }
  inline LinuxHardwareStatus& operator=(LinuxHardwareStatus&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LinuxHardwareStatus& default_instance() {
    return *internal_default_instance();
  }
  static inline const LinuxHardwareStatus* internal_default_instance() {
    return reinterpret_cast<const LinuxHardwareStatus*>(
               &_LinuxHardwareStatus_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;
 
  friend void swap(LinuxHardwareStatus& a, LinuxHardwareStatus& b) {
    a.Swap(&b);
  }
  inline void Swap(LinuxHardwareStatus* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(LinuxHardwareStatus* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  LinuxHardwareStatus* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LinuxHardwareStatus>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LinuxHardwareStatus& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const LinuxHardwareStatus& from) {
    LinuxHardwareStatus::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LinuxHardwareStatus* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "jaiabot.protobuf.LinuxHardwareStatus";
  }
  protected:
  explicit LinuxHardwareStatus(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::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 -------------------------------------------------------
 
  enum : int {
    kProcessorFieldNumber = 20,
    kMemoryFieldNumber = 30,
    kDiskFieldNumber = 40,
    kWifiFieldNumber = 50,
    kUptimeFieldNumber = 10,
  };
  // optional .jaiabot.protobuf.LinuxHardwareStatus.Processor processor = 20;
  bool has_processor() const;
  private:
  bool _internal_has_processor() const;
  public:
  void clear_processor();
  const ::jaiabot::protobuf::LinuxHardwareStatus_Processor& processor() const;
  PROTOBUF_NODISCARD ::jaiabot::protobuf::LinuxHardwareStatus_Processor* release_processor();
  ::jaiabot::protobuf::LinuxHardwareStatus_Processor* mutable_processor();
  void set_allocated_processor(::jaiabot::protobuf::LinuxHardwareStatus_Processor* processor);
  private:
  const ::jaiabot::protobuf::LinuxHardwareStatus_Processor& _internal_processor() const;
  ::jaiabot::protobuf::LinuxHardwareStatus_Processor* _internal_mutable_processor();
  public:
  void unsafe_arena_set_allocated_processor(
      ::jaiabot::protobuf::LinuxHardwareStatus_Processor* processor);
  ::jaiabot::protobuf::LinuxHardwareStatus_Processor* unsafe_arena_release_processor();
 
  // optional .jaiabot.protobuf.LinuxHardwareStatus.Memory memory = 30;
  bool has_memory() const;
  private:
  bool _internal_has_memory() const;
  public:
  void clear_memory();
  const ::jaiabot::protobuf::LinuxHardwareStatus_Memory& memory() const;
  PROTOBUF_NODISCARD ::jaiabot::protobuf::LinuxHardwareStatus_Memory* release_memory();
  ::jaiabot::protobuf::LinuxHardwareStatus_Memory* mutable_memory();
  void set_allocated_memory(::jaiabot::protobuf::LinuxHardwareStatus_Memory* memory);
  private:
  const ::jaiabot::protobuf::LinuxHardwareStatus_Memory& _internal_memory() const;
  ::jaiabot::protobuf::LinuxHardwareStatus_Memory* _internal_mutable_memory();
  public:
  void unsafe_arena_set_allocated_memory(
      ::jaiabot::protobuf::LinuxHardwareStatus_Memory* memory);
  ::jaiabot::protobuf::LinuxHardwareStatus_Memory* unsafe_arena_release_memory();
 
  // optional .jaiabot.protobuf.LinuxHardwareStatus.Disk disk = 40;
  bool has_disk() const;
  private:
  bool _internal_has_disk() const;
  public:
  void clear_disk();
  const ::jaiabot::protobuf::LinuxHardwareStatus_Disk& disk() const;
  PROTOBUF_NODISCARD ::jaiabot::protobuf::LinuxHardwareStatus_Disk* release_disk();
  ::jaiabot::protobuf::LinuxHardwareStatus_Disk* mutable_disk();
  void set_allocated_disk(::jaiabot::protobuf::LinuxHardwareStatus_Disk* disk);
  private:
  const ::jaiabot::protobuf::LinuxHardwareStatus_Disk& _internal_disk() const;
  ::jaiabot::protobuf::LinuxHardwareStatus_Disk* _internal_mutable_disk();
  public:
  void unsafe_arena_set_allocated_disk(
      ::jaiabot::protobuf::LinuxHardwareStatus_Disk* disk);
  ::jaiabot::protobuf::LinuxHardwareStatus_Disk* unsafe_arena_release_disk();
 
  // optional .jaiabot.protobuf.LinuxHardwareStatus.WiFi wifi = 50;
  bool has_wifi() const;
  private:
  bool _internal_has_wifi() const;
  public:
  void clear_wifi();
  const ::jaiabot::protobuf::LinuxHardwareStatus_WiFi& wifi() const;
  PROTOBUF_NODISCARD ::jaiabot::protobuf::LinuxHardwareStatus_WiFi* release_wifi();
  ::jaiabot::protobuf::LinuxHardwareStatus_WiFi* mutable_wifi();
  void set_allocated_wifi(::jaiabot::protobuf::LinuxHardwareStatus_WiFi* wifi);
  private:
  const ::jaiabot::protobuf::LinuxHardwareStatus_WiFi& _internal_wifi() const;
  ::jaiabot::protobuf::LinuxHardwareStatus_WiFi* _internal_mutable_wifi();
  public:
  void unsafe_arena_set_allocated_wifi(
      ::jaiabot::protobuf::LinuxHardwareStatus_WiFi* wifi);
  ::jaiabot::protobuf::LinuxHardwareStatus_WiFi* unsafe_arena_release_wifi();
 
  // optional int32 uptime = 10 [(.dccl.field) = {
  bool has_uptime() const;
  private:
  bool _internal_has_uptime() const;
  public:
  void clear_uptime();
  int32_t uptime() const;
  void set_uptime(int32_t value);
  private:
  int32_t _internal_uptime() const;
  void _internal_set_uptime(int32_t value);
  public:
 
  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:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::jaiabot::protobuf::LinuxHardwareStatus_Processor* processor_;
    ::jaiabot::protobuf::LinuxHardwareStatus_Memory* memory_;
    ::jaiabot::protobuf::LinuxHardwareStatus_Disk* disk_;
    ::jaiabot::protobuf::LinuxHardwareStatus_WiFi* wifi_;
    int32_t uptime_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_jaiabot_2fmessages_2fhealth_2eproto;
};
// -------------------------------------------------------------------
 
class NTPStatus_NTPPeer final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:jaiabot.protobuf.NTPStatus.NTPPeer) */ {
 public:
  inline NTPStatus_NTPPeer() : NTPStatus_NTPPeer(nullptr) {}
  ~NTPStatus_NTPPeer() override;
  explicit PROTOBUF_CONSTEXPR NTPStatus_NTPPeer(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  NTPStatus_NTPPeer(const NTPStatus_NTPPeer& from);
  NTPStatus_NTPPeer(NTPStatus_NTPPeer&& from) noexcept
    : NTPStatus_NTPPeer() {
    *this = ::std::move(from);
  }
 
  inline NTPStatus_NTPPeer& operator=(const NTPStatus_NTPPeer& from) {
    CopyFrom(from);
    return *this;
  }
  inline NTPStatus_NTPPeer& operator=(NTPStatus_NTPPeer&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const NTPStatus_NTPPeer& default_instance() {
    return *internal_default_instance();
  }
  static inline const NTPStatus_NTPPeer* internal_default_instance() {
    return reinterpret_cast<const NTPStatus_NTPPeer*>(
               &_NTPStatus_NTPPeer_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;
 
  friend void swap(NTPStatus_NTPPeer& a, NTPStatus_NTPPeer& b) {
    a.Swap(&b);
  }
  inline void Swap(NTPStatus_NTPPeer* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(NTPStatus_NTPPeer* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  NTPStatus_NTPPeer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<NTPStatus_NTPPeer>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const NTPStatus_NTPPeer& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const NTPStatus_NTPPeer& from) {
    NTPStatus_NTPPeer::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NTPStatus_NTPPeer* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "jaiabot.protobuf.NTPStatus.NTPPeer";
  }
  protected:
  explicit NTPStatus_NTPPeer(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  typedef NTPStatus_NTPPeer_TallyCode TallyCode;
  static constexpr TallyCode PEER_CODE_UNKNOWN =
    NTPStatus_NTPPeer_TallyCode_PEER_CODE_UNKNOWN;
  static constexpr TallyCode PEER_NOT_VALID =
    NTPStatus_NTPPeer_TallyCode_PEER_NOT_VALID;
  static constexpr TallyCode PEER_DISCARDED_BY_INTERSECTION =
    NTPStatus_NTPPeer_TallyCode_PEER_DISCARDED_BY_INTERSECTION;
  static constexpr TallyCode PEER_DISCARDED_BY_TABLE_OVERFLOW =
    NTPStatus_NTPPeer_TallyCode_PEER_DISCARDED_BY_TABLE_OVERFLOW;
  static constexpr TallyCode PEER_DISCARDED_BY_CLUSTER_ALGORITHM =
    NTPStatus_NTPPeer_TallyCode_PEER_DISCARDED_BY_CLUSTER_ALGORITHM;
  static constexpr TallyCode PEER_INCLUDED_IN_COMBINE =
    NTPStatus_NTPPeer_TallyCode_PEER_INCLUDED_IN_COMBINE;
  static constexpr TallyCode PEER_ALTERNATIVE_BACKUP =
    NTPStatus_NTPPeer_TallyCode_PEER_ALTERNATIVE_BACKUP;
  static constexpr TallyCode PEER_SYSTEM_SYNC_SOURCE =
    NTPStatus_NTPPeer_TallyCode_PEER_SYSTEM_SYNC_SOURCE;
  static constexpr TallyCode PEER_PPS_SYNC =
    NTPStatus_NTPPeer_TallyCode_PEER_PPS_SYNC;
  static inline bool TallyCode_IsValid(int value) {
    return NTPStatus_NTPPeer_TallyCode_IsValid(value);
  }
  static constexpr TallyCode TallyCode_MIN =
    NTPStatus_NTPPeer_TallyCode_TallyCode_MIN;
  static constexpr TallyCode TallyCode_MAX =
    NTPStatus_NTPPeer_TallyCode_TallyCode_MAX;
  static constexpr int TallyCode_ARRAYSIZE =
    NTPStatus_NTPPeer_TallyCode_TallyCode_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  TallyCode_descriptor() {
    return NTPStatus_NTPPeer_TallyCode_descriptor();
  }
  template<typename T>
  static inline const std::string& TallyCode_Name(T enum_t_value) {
    static_assert(::std::is_same<T, TallyCode>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function TallyCode_Name.");
    return NTPStatus_NTPPeer_TallyCode_Name(enum_t_value);
  }
  static inline bool TallyCode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      TallyCode* value) {
    return NTPStatus_NTPPeer_TallyCode_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kRemoteFieldNumber = 2,
    kRefidFieldNumber = 3,
    kReachFieldNumber = 7,
    kJitterFieldNumber = 10,
    kTallyCodeFieldNumber = 1,
    kStratumFieldNumber = 4,
    kWhenFieldNumber = 5,
    kPollFieldNumber = 6,
    kDelayFieldNumber = 8,
    kOffsetFieldNumber = 9,
  };
  // required string remote = 2;
  bool has_remote() const;
  private:
  bool _internal_has_remote() const;
  public:
  void clear_remote();
  const std::string& remote() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_remote(ArgT0&& arg0, ArgT... args);
  std::string* mutable_remote();
  PROTOBUF_NODISCARD std::string* release_remote();
  void set_allocated_remote(std::string* remote);
  private:
  const std::string& _internal_remote() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_remote(const std::string& value);
  std::string* _internal_mutable_remote();
  public:
 
  // required string refid = 3;
  bool has_refid() const;
  private:
  bool _internal_has_refid() const;
  public:
  void clear_refid();
  const std::string& refid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_refid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_refid();
  PROTOBUF_NODISCARD std::string* release_refid();
  void set_allocated_refid(std::string* refid);
  private:
  const std::string& _internal_refid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_refid(const std::string& value);
  std::string* _internal_mutable_refid();
  public:
 
  // optional int32 reach = 7 [default = 0];
  bool has_reach() const;
  private:
  bool _internal_has_reach() const;
  public:
  void clear_reach();
  int32_t reach() const;
  void set_reach(int32_t value);
  private:
  int32_t _internal_reach() const;
  void _internal_set_reach(int32_t value);
  public:
 
  // optional float jitter = 10 [default = nan, (.dccl.field) = {
  bool has_jitter() const;
  private:
  bool _internal_has_jitter() const;
  public:
  void clear_jitter();
  float jitter() const;
  void set_jitter(float value);
  private:
  float _internal_jitter() const;
  void _internal_set_jitter(float value);
  public:
 
  // required .jaiabot.protobuf.NTPStatus.NTPPeer.TallyCode tally_code = 1 [default = PEER_CODE_UNKNOWN];
  bool has_tally_code() const;
  private:
  bool _internal_has_tally_code() const;
  public:
  void clear_tally_code();
  ::jaiabot::protobuf::NTPStatus_NTPPeer_TallyCode tally_code() const;
  void set_tally_code(::jaiabot::protobuf::NTPStatus_NTPPeer_TallyCode value);
  private:
  ::jaiabot::protobuf::NTPStatus_NTPPeer_TallyCode _internal_tally_code() const;
  void _internal_set_tally_code(::jaiabot::protobuf::NTPStatus_NTPPeer_TallyCode value);
  public:
 
  // optional int32 stratum = 4 [default = 16];
  bool has_stratum() const;
  private:
  bool _internal_has_stratum() const;
  public:
  void clear_stratum();
  int32_t stratum() const;
  void set_stratum(int32_t value);
  private:
  int32_t _internal_stratum() const;
  void _internal_set_stratum(int32_t value);
  public:
 
  // optional int32 when = 5 [default = -1, (.dccl.field) = {
  bool has_when() const;
  private:
  bool _internal_has_when() const;
  public:
  void clear_when();
  int32_t when() const;
  void set_when(int32_t value);
  private:
  int32_t _internal_when() const;
  void _internal_set_when(int32_t value);
  public:
 
  // optional int32 poll = 6 [default = -1, (.dccl.field) = {
  bool has_poll() const;
  private:
  bool _internal_has_poll() const;
  public:
  void clear_poll();
  int32_t poll() const;
  void set_poll(int32_t value);
  private:
  int32_t _internal_poll() const;
  void _internal_set_poll(int32_t value);
  public:
 
  // optional float delay = 8 [default = nan, (.dccl.field) = {
  bool has_delay() const;
  private:
  bool _internal_has_delay() const;
  public:
  void clear_delay();
  float delay() const;
  void set_delay(float value);
  private:
  float _internal_delay() const;
  void _internal_set_delay(float value);
  public:
 
  // optional float offset = 9 [default = nan, (.dccl.field) = {
  bool has_offset() const;
  private:
  bool _internal_has_offset() const;
  public:
  void clear_offset();
  float offset() const;
  void set_offset(float value);
  private:
  float _internal_offset() const;
  void _internal_set_offset(float value);
  public:
 
  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:
  class _Internal;
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr remote_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr refid_;
    int32_t reach_;
    float jitter_;
    int tally_code_;
    int32_t stratum_;
    int32_t when_;
    int32_t poll_;
    float delay_;
    float offset_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_jaiabot_2fmessages_2fhealth_2eproto;
};
// -------------------------------------------------------------------
 
class NTPStatus final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:jaiabot.protobuf.NTPStatus) */ {
 public:
  inline NTPStatus() : NTPStatus(nullptr) {}
  ~NTPStatus() override;
  explicit PROTOBUF_CONSTEXPR NTPStatus(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  NTPStatus(const NTPStatus& from);
  NTPStatus(NTPStatus&& from) noexcept
    : NTPStatus() {
    *this = ::std::move(from);
  }
 
  inline NTPStatus& operator=(const NTPStatus& from) {
    CopyFrom(from);
    return *this;
  }
  inline NTPStatus& operator=(NTPStatus&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const NTPStatus& default_instance() {
    return *internal_default_instance();
  }
  static inline const NTPStatus* internal_default_instance() {
    return reinterpret_cast<const NTPStatus*>(
               &_NTPStatus_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;
 
  friend void swap(NTPStatus& a, NTPStatus& b) {
    a.Swap(&b);
  }
  inline void Swap(NTPStatus* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(NTPStatus* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  NTPStatus* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<NTPStatus>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const NTPStatus& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const NTPStatus& from) {
    NTPStatus::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NTPStatus* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "jaiabot.protobuf.NTPStatus";
  }
  protected:
  explicit NTPStatus(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  typedef NTPStatus_NTPPeer NTPPeer;
 
  typedef NTPStatus_SyncSource SyncSource;
  static constexpr SyncSource SYNC_UNKNOWN =
    NTPStatus_SyncSource_SYNC_UNKNOWN;
  static constexpr SyncSource SYNC_UNSPECIFIED =
    NTPStatus_SyncSource_SYNC_UNSPECIFIED;
  static constexpr SyncSource SYNC_PPS =
    NTPStatus_SyncSource_SYNC_PPS;
  static constexpr SyncSource SYNC_LF_RADIO =
    NTPStatus_SyncSource_SYNC_LF_RADIO;
  static constexpr SyncSource SYNC_HF_RADIO =
    NTPStatus_SyncSource_SYNC_HF_RADIO;
  static constexpr SyncSource SYNC_UHF_RADIO =
    NTPStatus_SyncSource_SYNC_UHF_RADIO;
  static constexpr SyncSource SYNC_LOCAL =
    NTPStatus_SyncSource_SYNC_LOCAL;
  static constexpr SyncSource SYNC_NTP =
    NTPStatus_SyncSource_SYNC_NTP;
  static constexpr SyncSource SYNC_OTHER =
    NTPStatus_SyncSource_SYNC_OTHER;
  static constexpr SyncSource SYNC_WRISTWATCH =
    NTPStatus_SyncSource_SYNC_WRISTWATCH;
  static constexpr SyncSource SYNC_TELEPHONE =
    NTPStatus_SyncSource_SYNC_TELEPHONE;
  static inline bool SyncSource_IsValid(int value) {
    return NTPStatus_SyncSource_IsValid(value);
  }
  static constexpr SyncSource SyncSource_MIN =
    NTPStatus_SyncSource_SyncSource_MIN;
  static constexpr SyncSource SyncSource_MAX =
    NTPStatus_SyncSource_SyncSource_MAX;
  static constexpr int SyncSource_ARRAYSIZE =
    NTPStatus_SyncSource_SyncSource_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  SyncSource_descriptor() {
    return NTPStatus_SyncSource_descriptor();
  }
  template<typename T>
  static inline const std::string& SyncSource_Name(T enum_t_value) {
    static_assert(::std::is_same<T, SyncSource>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function SyncSource_Name.");
    return NTPStatus_SyncSource_Name(enum_t_value);
  }
  static inline bool SyncSource_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      SyncSource* value) {
    return NTPStatus_SyncSource_Parse(name, value);
  }
 
  typedef NTPStatus_LeapIndicator LeapIndicator;
  static constexpr LeapIndicator LEAP_UNKNOWN =
    NTPStatus_LeapIndicator_LEAP_UNKNOWN;
  static constexpr LeapIndicator LEAP_NONE =
    NTPStatus_LeapIndicator_LEAP_NONE;
  static constexpr LeapIndicator LEAP_LAST_MINUTE_HAS_61_SECONDS =
    NTPStatus_LeapIndicator_LEAP_LAST_MINUTE_HAS_61_SECONDS;
  static constexpr LeapIndicator LEAP_LAST_MINUTE_HAS_59_SECONDS =
    NTPStatus_LeapIndicator_LEAP_LAST_MINUTE_HAS_59_SECONDS;
  static constexpr LeapIndicator LEAP_CLOCK_NOT_SYNCHRONIZED =
    NTPStatus_LeapIndicator_LEAP_CLOCK_NOT_SYNCHRONIZED;
  static inline bool LeapIndicator_IsValid(int value) {
    return NTPStatus_LeapIndicator_IsValid(value);
  }
  static constexpr LeapIndicator LeapIndicator_MIN =
    NTPStatus_LeapIndicator_LeapIndicator_MIN;
  static constexpr LeapIndicator LeapIndicator_MAX =
    NTPStatus_LeapIndicator_LeapIndicator_MAX;
  static constexpr int LeapIndicator_ARRAYSIZE =
    NTPStatus_LeapIndicator_LeapIndicator_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  LeapIndicator_descriptor() {
    return NTPStatus_LeapIndicator_descriptor();
  }
  template<typename T>
  static inline const std::string& LeapIndicator_Name(T enum_t_value) {
    static_assert(::std::is_same<T, LeapIndicator>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function LeapIndicator_Name.");
    return NTPStatus_LeapIndicator_Name(enum_t_value);
  }
  static inline bool LeapIndicator_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      LeapIndicator* value) {
    return NTPStatus_LeapIndicator_Parse(name, value);
  }
 
  typedef NTPStatus_NTPSystemEvent NTPSystemEvent;
  static constexpr NTPSystemEvent NTP_SYSTEM_EVENT_UNKNOWN =
    NTPStatus_NTPSystemEvent_NTP_SYSTEM_EVENT_UNKNOWN;
  static constexpr NTPSystemEvent NTP_SYSTEM_EVENT_UNSPECIFIED =
    NTPStatus_NTPSystemEvent_NTP_SYSTEM_EVENT_UNSPECIFIED;
  static constexpr NTPSystemEvent NTP_SYSTEM_FREQ_NOT_SET =
    NTPStatus_NTPSystemEvent_NTP_SYSTEM_FREQ_NOT_SET;
  static constexpr NTPSystemEvent NTP_SYSTEM_FREQ_SET =
    NTPStatus_NTPSystemEvent_NTP_SYSTEM_FREQ_SET;
  static constexpr NTPSystemEvent NTP_SYSTEM_SPIKE_DETECT =
    NTPStatus_NTPSystemEvent_NTP_SYSTEM_SPIKE_DETECT;
  static constexpr NTPSystemEvent NTP_SYSTEM_FREQ_MODE =
    NTPStatus_NTPSystemEvent_NTP_SYSTEM_FREQ_MODE;
  static constexpr NTPSystemEvent NTP_SYSTEM_CLOCK_SYNC =
    NTPStatus_NTPSystemEvent_NTP_SYSTEM_CLOCK_SYNC;
  static constexpr NTPSystemEvent NTP_SYSTEM_RESTART =
    NTPStatus_NTPSystemEvent_NTP_SYSTEM_RESTART;
  static constexpr NTPSystemEvent NTP_SYSTEM_PANIC_STOP =
    NTPStatus_NTPSystemEvent_NTP_SYSTEM_PANIC_STOP;
  static constexpr NTPSystemEvent NTP_SYSTEM_NO_SYSTEM_PEER =
    NTPStatus_NTPSystemEvent_NTP_SYSTEM_NO_SYSTEM_PEER;
  static constexpr NTPSystemEvent NTP_SYSTEM_LEAP_ARMED =
    NTPStatus_NTPSystemEvent_NTP_SYSTEM_LEAP_ARMED;
  static constexpr NTPSystemEvent NTP_SYSTEM_LEAP_DISARMED =
    NTPStatus_NTPSystemEvent_NTP_SYSTEM_LEAP_DISARMED;
  static constexpr NTPSystemEvent NTP_SYSTEM_LEAP_EVENT =
    NTPStatus_NTPSystemEvent_NTP_SYSTEM_LEAP_EVENT;
  static constexpr NTPSystemEvent NTP_SYSTEM_CLOCK_STEP =
    NTPStatus_NTPSystemEvent_NTP_SYSTEM_CLOCK_STEP;
  static constexpr NTPSystemEvent NTP_SYSTEM_KERNEL_INFO =
    NTPStatus_NTPSystemEvent_NTP_SYSTEM_KERNEL_INFO;
  static constexpr NTPSystemEvent NTP_SYSTEM_LEAPSECOND_VALUES_UPDATE_FROM_FILE =
    NTPStatus_NTPSystemEvent_NTP_SYSTEM_LEAPSECOND_VALUES_UPDATE_FROM_FILE;
  static constexpr 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 constexpr NTPSystemEvent NTPSystemEvent_MIN =
    NTPStatus_NTPSystemEvent_NTPSystemEvent_MIN;
  static constexpr NTPSystemEvent NTPSystemEvent_MAX =
    NTPStatus_NTPSystemEvent_NTPSystemEvent_MAX;
  static constexpr int NTPSystemEvent_ARRAYSIZE =
    NTPStatus_NTPSystemEvent_NTPSystemEvent_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  NTPSystemEvent_descriptor() {
    return NTPStatus_NTPSystemEvent_descriptor();
  }
  template<typename T>
  static inline const std::string& NTPSystemEvent_Name(T enum_t_value) {
    static_assert(::std::is_same<T, NTPSystemEvent>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function NTPSystemEvent_Name.");
    return NTPStatus_NTPSystemEvent_Name(enum_t_value);
  }
  static inline bool NTPSystemEvent_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      NTPSystemEvent* value) {
    return NTPStatus_NTPSystemEvent_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kPeerFieldNumber = 21,
    kSystemSyncPeerFieldNumber = 20,
    kSystemEventCounterFieldNumber = 12,
    kLastSystemEventFieldNumber = 13,
    kSyncSourceFieldNumber = 10,
    kLeapIndicatorFieldNumber = 11,
  };
  // repeated .jaiabot.protobuf.NTPStatus.NTPPeer peer = 21;
  int peer_size() const;
  private:
  int _internal_peer_size() const;
  public:
  void clear_peer();
  ::jaiabot::protobuf::NTPStatus_NTPPeer* mutable_peer(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::jaiabot::protobuf::NTPStatus_NTPPeer >*
      mutable_peer();
  private:
  const ::jaiabot::protobuf::NTPStatus_NTPPeer& _internal_peer(int index) const;
  ::jaiabot::protobuf::NTPStatus_NTPPeer* _internal_add_peer();
  public:
  const ::jaiabot::protobuf::NTPStatus_NTPPeer& peer(int index) const;
  ::jaiabot::protobuf::NTPStatus_NTPPeer* add_peer();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::jaiabot::protobuf::NTPStatus_NTPPeer >&
      peer() const;
 
  // optional .jaiabot.protobuf.NTPStatus.NTPPeer system_sync_peer = 20;
  bool has_system_sync_peer() const;
  private:
  bool _internal_has_system_sync_peer() const;
  public:
  void clear_system_sync_peer();
  const ::jaiabot::protobuf::NTPStatus_NTPPeer& system_sync_peer() const;
  PROTOBUF_NODISCARD ::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);
  private:
  const ::jaiabot::protobuf::NTPStatus_NTPPeer& _internal_system_sync_peer() const;
  ::jaiabot::protobuf::NTPStatus_NTPPeer* _internal_mutable_system_sync_peer();
  public:
  void unsafe_arena_set_allocated_system_sync_peer(
      ::jaiabot::protobuf::NTPStatus_NTPPeer* system_sync_peer);
  ::jaiabot::protobuf::NTPStatus_NTPPeer* unsafe_arena_release_system_sync_peer();
 
  // optional int32 system_event_counter = 12 [default = 0];
  bool has_system_event_counter() const;
  private:
  bool _internal_has_system_event_counter() const;
  public:
  void clear_system_event_counter();
  int32_t system_event_counter() const;
  void set_system_event_counter(int32_t value);
  private:
  int32_t _internal_system_event_counter() const;
  void _internal_set_system_event_counter(int32_t value);
  public:
 
  // optional .jaiabot.protobuf.NTPStatus.NTPSystemEvent last_system_event = 13 [default = NTP_SYSTEM_EVENT_UNKNOWN];
  bool has_last_system_event() const;
  private:
  bool _internal_has_last_system_event() const;
  public:
  void clear_last_system_event();
  ::jaiabot::protobuf::NTPStatus_NTPSystemEvent last_system_event() const;
  void set_last_system_event(::jaiabot::protobuf::NTPStatus_NTPSystemEvent value);
  private:
  ::jaiabot::protobuf::NTPStatus_NTPSystemEvent _internal_last_system_event() const;
  void _internal_set_last_system_event(::jaiabot::protobuf::NTPStatus_NTPSystemEvent value);
  public:
 
  // optional .jaiabot.protobuf.NTPStatus.SyncSource sync_source = 10 [default = SYNC_UNKNOWN];
  bool has_sync_source() const;
  private:
  bool _internal_has_sync_source() const;
  public:
  void clear_sync_source();
  ::jaiabot::protobuf::NTPStatus_SyncSource sync_source() const;
  void set_sync_source(::jaiabot::protobuf::NTPStatus_SyncSource value);
  private:
  ::jaiabot::protobuf::NTPStatus_SyncSource _internal_sync_source() const;
  void _internal_set_sync_source(::jaiabot::protobuf::NTPStatus_SyncSource value);
  public:
 
  // optional .jaiabot.protobuf.NTPStatus.LeapIndicator leap_indicator = 11 [default = LEAP_UNKNOWN];
  bool has_leap_indicator() const;
  private:
  bool _internal_has_leap_indicator() const;
  public:
  void clear_leap_indicator();
  ::jaiabot::protobuf::NTPStatus_LeapIndicator leap_indicator() const;
  void set_leap_indicator(::jaiabot::protobuf::NTPStatus_LeapIndicator value);
  private:
  ::jaiabot::protobuf::NTPStatus_LeapIndicator _internal_leap_indicator() const;
  void _internal_set_leap_indicator(::jaiabot::protobuf::NTPStatus_LeapIndicator value);
  public:
 
  // @@protoc_insertion_point(class_scope:jaiabot.protobuf.NTPStatus)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::jaiabot::protobuf::NTPStatus_NTPPeer > peer_;
    ::jaiabot::protobuf::NTPStatus_NTPPeer* system_sync_peer_;
    int32_t system_event_counter_;
    int last_system_event_;
    int sync_source_;
    int leap_indicator_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_jaiabot_2fmessages_2fhealth_2eproto;
};
// -------------------------------------------------------------------
 
class HelmIVPStatus final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:jaiabot.protobuf.HelmIVPStatus) */ {
 public:
  inline HelmIVPStatus() : HelmIVPStatus(nullptr) {}
  ~HelmIVPStatus() override;
  explicit PROTOBUF_CONSTEXPR HelmIVPStatus(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  HelmIVPStatus(const HelmIVPStatus& from);
  HelmIVPStatus(HelmIVPStatus&& from) noexcept
    : HelmIVPStatus() {
    *this = ::std::move(from);
  }
 
  inline HelmIVPStatus& operator=(const HelmIVPStatus& from) {
    CopyFrom(from);
    return *this;
  }
  inline HelmIVPStatus& operator=(HelmIVPStatus&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const HelmIVPStatus& default_instance() {
    return *internal_default_instance();
  }
  static inline const HelmIVPStatus* internal_default_instance() {
    return reinterpret_cast<const HelmIVPStatus*>(
               &_HelmIVPStatus_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;
 
  friend void swap(HelmIVPStatus& a, HelmIVPStatus& b) {
    a.Swap(&b);
  }
  inline void Swap(HelmIVPStatus* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(HelmIVPStatus* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  HelmIVPStatus* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HelmIVPStatus>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HelmIVPStatus& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HelmIVPStatus& from) {
    HelmIVPStatus::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(HelmIVPStatus* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "jaiabot.protobuf.HelmIVPStatus";
  }
  protected:
  explicit HelmIVPStatus(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kHelmIvpStateFieldNumber = 1,
    kHelmIvpDesiredSpeedFieldNumber = 2,
    kHelmIvpDesiredHeadingFieldNumber = 3,
    kHelmIvpDesiredDepthFieldNumber = 4,
    kHelmIvpDataFieldNumber = 5,
  };
  // optional string helm_ivp_state = 1 [default = "PARK"];
  bool has_helm_ivp_state() const;
  private:
  bool _internal_has_helm_ivp_state() const;
  public:
  void clear_helm_ivp_state();
  const std::string& helm_ivp_state() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_helm_ivp_state(ArgT0&& arg0, ArgT... args);
  std::string* mutable_helm_ivp_state();
  PROTOBUF_NODISCARD std::string* release_helm_ivp_state();
  void set_allocated_helm_ivp_state(std::string* helm_ivp_state);
  private:
  const std::string& _internal_helm_ivp_state() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_helm_ivp_state(const std::string& value);
  std::string* _internal_mutable_helm_ivp_state();
  public:
 
  // optional bool helm_ivp_desired_speed = 2 [default = false];
  bool has_helm_ivp_desired_speed() const;
  private:
  bool _internal_has_helm_ivp_desired_speed() const;
  public:
  void clear_helm_ivp_desired_speed();
  bool helm_ivp_desired_speed() const;
  void set_helm_ivp_desired_speed(bool value);
  private:
  bool _internal_helm_ivp_desired_speed() const;
  void _internal_set_helm_ivp_desired_speed(bool value);
  public:
 
  // optional bool helm_ivp_desired_heading = 3 [default = false];
  bool has_helm_ivp_desired_heading() const;
  private:
  bool _internal_has_helm_ivp_desired_heading() const;
  public:
  void clear_helm_ivp_desired_heading();
  bool helm_ivp_desired_heading() const;
  void set_helm_ivp_desired_heading(bool value);
  private:
  bool _internal_helm_ivp_desired_heading() const;
  void _internal_set_helm_ivp_desired_heading(bool value);
  public:
 
  // optional bool helm_ivp_desired_depth = 4 [default = false];
  bool has_helm_ivp_desired_depth() const;
  private:
  bool _internal_has_helm_ivp_desired_depth() const;
  public:
  void clear_helm_ivp_desired_depth();
  bool helm_ivp_desired_depth() const;
  void set_helm_ivp_desired_depth(bool value);
  private:
  bool _internal_helm_ivp_desired_depth() const;
  void _internal_set_helm_ivp_desired_depth(bool value);
  public:
 
  // optional bool helm_ivp_data = 5 [default = false];
  bool has_helm_ivp_data() const;
  private:
  bool _internal_has_helm_ivp_data() const;
  public:
  void clear_helm_ivp_data();
  bool helm_ivp_data() const;
  void set_helm_ivp_data(bool value);
  private:
  bool _internal_helm_ivp_data() const;
  void _internal_set_helm_ivp_data(bool value);
  public:
 
  // @@protoc_insertion_point(class_scope:jaiabot.protobuf.HelmIVPStatus)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_helm_ivp_state_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr helm_ivp_state_;
    bool helm_ivp_desired_speed_;
    bool helm_ivp_desired_heading_;
    bool helm_ivp_desired_depth_;
    bool helm_ivp_data_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_jaiabot_2fmessages_2fhealth_2eproto;
};
// -------------------------------------------------------------------
 
class ThreadHealth final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:jaiabot.protobuf.ThreadHealth) */ {
 public:
  inline ThreadHealth() : ThreadHealth(nullptr) {}
  ~ThreadHealth() override;
  explicit PROTOBUF_CONSTEXPR ThreadHealth(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  ThreadHealth(const ThreadHealth& from);
  ThreadHealth(ThreadHealth&& from) noexcept
    : ThreadHealth() {
    *this = ::std::move(from);
  }
 
  inline ThreadHealth& operator=(const ThreadHealth& from) {
    CopyFrom(from);
    return *this;
  }
  inline ThreadHealth& operator=(ThreadHealth&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ThreadHealth& default_instance() {
    return *internal_default_instance();
  }
  static inline const ThreadHealth* internal_default_instance() {
    return reinterpret_cast<const ThreadHealth*>(
               &_ThreadHealth_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;
 
  friend void swap(ThreadHealth& a, ThreadHealth& b) {
    a.Swap(&b);
  }
  inline void Swap(ThreadHealth* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ThreadHealth* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  ThreadHealth* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ThreadHealth>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ThreadHealth& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ThreadHealth& from) {
    ThreadHealth::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ThreadHealth* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "jaiabot.protobuf.ThreadHealth";
  }
  protected:
  explicit ThreadHealth(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kErrorFieldNumber = 1,
    kWarningFieldNumber = 2,
  };
  // repeated .jaiabot.protobuf.Error error = 1;
  int error_size() const;
  private:
  int _internal_error_size() const;
  public:
  void clear_error();
  private:
  ::jaiabot::protobuf::Error _internal_error(int index) const;
  void _internal_add_error(::jaiabot::protobuf::Error value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_error();
  public:
  ::jaiabot::protobuf::Error error(int index) const;
  void set_error(int index, ::jaiabot::protobuf::Error value);
  void add_error(::jaiabot::protobuf::Error value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& error() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_error();
 
  // repeated .jaiabot.protobuf.Warning warning = 2;
  int warning_size() const;
  private:
  int _internal_warning_size() const;
  public:
  void clear_warning();
  private:
  ::jaiabot::protobuf::Warning _internal_warning(int index) const;
  void _internal_add_warning(::jaiabot::protobuf::Warning value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_warning();
  public:
  ::jaiabot::protobuf::Warning warning(int index) const;
  void set_warning(int index, ::jaiabot::protobuf::Warning value);
  void add_warning(::jaiabot::protobuf::Warning value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& warning() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_warning();
 
  // @@protoc_insertion_point(class_scope:jaiabot.protobuf.ThreadHealth)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> error_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> warning_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_jaiabot_2fmessages_2fhealth_2eproto;
};
// -------------------------------------------------------------------
 
class VehicleHealth final :
    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:jaiabot.protobuf.VehicleHealth) */ {
 public:
  inline VehicleHealth() : VehicleHealth(nullptr) {}
  explicit PROTOBUF_CONSTEXPR VehicleHealth(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  VehicleHealth(const VehicleHealth& from);
  VehicleHealth(VehicleHealth&& from) noexcept
    : VehicleHealth() {
    *this = ::std::move(from);
  }
 
  inline VehicleHealth& operator=(const VehicleHealth& from) {
    CopyFrom(from);
    return *this;
  }
  inline VehicleHealth& operator=(VehicleHealth&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const VehicleHealth& default_instance() {
    return *internal_default_instance();
  }
  static inline const VehicleHealth* internal_default_instance() {
    return reinterpret_cast<const VehicleHealth*>(
               &_VehicleHealth_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;
 
  friend void swap(VehicleHealth& a, VehicleHealth& b) {
    a.Swap(&b);
  }
  inline void Swap(VehicleHealth* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(VehicleHealth* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  VehicleHealth* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<VehicleHealth>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const VehicleHealth& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const VehicleHealth& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from);
  }
  public:
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "jaiabot.protobuf.VehicleHealth";
  }
  protected:
  explicit VehicleHealth(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // @@protoc_insertion_point(class_scope:jaiabot.protobuf.VehicleHealth)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
  };
  friend struct ::TableStruct_jaiabot_2fmessages_2fhealth_2eproto;
};
// -------------------------------------------------------------------
 
class SystemdStartReport final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:jaiabot.protobuf.SystemdStartReport) */ {
 public:
  inline SystemdStartReport() : SystemdStartReport(nullptr) {}
  ~SystemdStartReport() override;
  explicit PROTOBUF_CONSTEXPR SystemdStartReport(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  SystemdStartReport(const SystemdStartReport& from);
  SystemdStartReport(SystemdStartReport&& from) noexcept
    : SystemdStartReport() {
    *this = ::std::move(from);
  }
 
  inline SystemdStartReport& operator=(const SystemdStartReport& from) {
    CopyFrom(from);
    return *this;
  }
  inline SystemdStartReport& operator=(SystemdStartReport&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SystemdStartReport& default_instance() {
    return *internal_default_instance();
  }
  static inline const SystemdStartReport* internal_default_instance() {
    return reinterpret_cast<const SystemdStartReport*>(
               &_SystemdStartReport_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;
 
  friend void swap(SystemdStartReport& a, SystemdStartReport& b) {
    a.Swap(&b);
  }
  inline void Swap(SystemdStartReport* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SystemdStartReport* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  SystemdStartReport* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SystemdStartReport>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SystemdStartReport& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SystemdStartReport& from) {
    SystemdStartReport::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SystemdStartReport* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "jaiabot.protobuf.SystemdStartReport";
  }
  protected:
  explicit SystemdStartReport(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kClearErrorFieldNumber = 1,
  };
  // required .jaiabot.protobuf.Error clear_error = 1;
  bool has_clear_error() const;
  private:
  bool _internal_has_clear_error() const;
  public:
  void clear_clear_error();
  ::jaiabot::protobuf::Error clear_error() const;
  void set_clear_error(::jaiabot::protobuf::Error value);
  private:
  ::jaiabot::protobuf::Error _internal_clear_error() const;
  void _internal_set_clear_error(::jaiabot::protobuf::Error value);
  public:
 
  // @@protoc_insertion_point(class_scope:jaiabot.protobuf.SystemdStartReport)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int clear_error_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_jaiabot_2fmessages_2fhealth_2eproto;
};
// -------------------------------------------------------------------
 
class SystemdStopReport final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:jaiabot.protobuf.SystemdStopReport) */ {
 public:
  inline SystemdStopReport() : SystemdStopReport(nullptr) {}
  ~SystemdStopReport() override;
  explicit PROTOBUF_CONSTEXPR SystemdStopReport(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  SystemdStopReport(const SystemdStopReport& from);
  SystemdStopReport(SystemdStopReport&& from) noexcept
    : SystemdStopReport() {
    *this = ::std::move(from);
  }
 
  inline SystemdStopReport& operator=(const SystemdStopReport& from) {
    CopyFrom(from);
    return *this;
  }
  inline SystemdStopReport& operator=(SystemdStopReport&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SystemdStopReport& default_instance() {
    return *internal_default_instance();
  }
  static inline const SystemdStopReport* internal_default_instance() {
    return reinterpret_cast<const SystemdStopReport*>(
               &_SystemdStopReport_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;
 
  friend void swap(SystemdStopReport& a, SystemdStopReport& b) {
    a.Swap(&b);
  }
  inline void Swap(SystemdStopReport* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SystemdStopReport* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  SystemdStopReport* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SystemdStopReport>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SystemdStopReport& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SystemdStopReport& from) {
    SystemdStopReport::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SystemdStopReport* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "jaiabot.protobuf.SystemdStopReport";
  }
  protected:
  explicit SystemdStopReport(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  typedef SystemdStopReport_ServiceResult ServiceResult;
  static constexpr ServiceResult SERVICE_RESULT_UNKNOWN =
    SystemdStopReport_ServiceResult_SERVICE_RESULT_UNKNOWN;
  static constexpr ServiceResult SERVICE_RESULT_SUCCESS =
    SystemdStopReport_ServiceResult_SERVICE_RESULT_SUCCESS;
  static constexpr ServiceResult SERVICE_RESULT_PROTOCOL =
    SystemdStopReport_ServiceResult_SERVICE_RESULT_PROTOCOL;
  static constexpr ServiceResult SERVICE_RESULT_TIMEOUT =
    SystemdStopReport_ServiceResult_SERVICE_RESULT_TIMEOUT;
  static constexpr ServiceResult SERVICE_RESULT_EXIT_CODE =
    SystemdStopReport_ServiceResult_SERVICE_RESULT_EXIT_CODE;
  static constexpr ServiceResult SERVICE_RESULT_SIGNAL =
    SystemdStopReport_ServiceResult_SERVICE_RESULT_SIGNAL;
  static constexpr ServiceResult SERVICE_RESULT_CORE_DUMP =
    SystemdStopReport_ServiceResult_SERVICE_RESULT_CORE_DUMP;
  static constexpr ServiceResult SERVICE_RESULT_WATCHDOG =
    SystemdStopReport_ServiceResult_SERVICE_RESULT_WATCHDOG;
  static constexpr ServiceResult SERVICE_RESULT_START_LIMIT_HIT =
    SystemdStopReport_ServiceResult_SERVICE_RESULT_START_LIMIT_HIT;
  static constexpr ServiceResult SERVICE_RESULT_RESOURCES =
    SystemdStopReport_ServiceResult_SERVICE_RESULT_RESOURCES;
  static inline bool ServiceResult_IsValid(int value) {
    return SystemdStopReport_ServiceResult_IsValid(value);
  }
  static constexpr ServiceResult ServiceResult_MIN =
    SystemdStopReport_ServiceResult_ServiceResult_MIN;
  static constexpr ServiceResult ServiceResult_MAX =
    SystemdStopReport_ServiceResult_ServiceResult_MAX;
  static constexpr int ServiceResult_ARRAYSIZE =
    SystemdStopReport_ServiceResult_ServiceResult_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  ServiceResult_descriptor() {
    return SystemdStopReport_ServiceResult_descriptor();
  }
  template<typename T>
  static inline const std::string& ServiceResult_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ServiceResult>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ServiceResult_Name.");
    return SystemdStopReport_ServiceResult_Name(enum_t_value);
  }
  static inline bool ServiceResult_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      ServiceResult* value) {
    return SystemdStopReport_ServiceResult_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kJournalDumpFileFieldNumber = 3,
    kResultFieldNumber = 1,
    kErrorFieldNumber = 2,
  };
  // optional string journal_dump_file = 3;
  bool has_journal_dump_file() const;
  private:
  bool _internal_has_journal_dump_file() const;
  public:
  void clear_journal_dump_file();
  const std::string& journal_dump_file() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_journal_dump_file(ArgT0&& arg0, ArgT... args);
  std::string* mutable_journal_dump_file();
  PROTOBUF_NODISCARD std::string* release_journal_dump_file();
  void set_allocated_journal_dump_file(std::string* journal_dump_file);
  private:
  const std::string& _internal_journal_dump_file() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_journal_dump_file(const std::string& value);
  std::string* _internal_mutable_journal_dump_file();
  public:
 
  // required .jaiabot.protobuf.SystemdStopReport.ServiceResult result = 1;
  bool has_result() const;
  private:
  bool _internal_has_result() const;
  public:
  void clear_result();
  ::jaiabot::protobuf::SystemdStopReport_ServiceResult result() const;
  void set_result(::jaiabot::protobuf::SystemdStopReport_ServiceResult value);
  private:
  ::jaiabot::protobuf::SystemdStopReport_ServiceResult _internal_result() const;
  void _internal_set_result(::jaiabot::protobuf::SystemdStopReport_ServiceResult value);
  public:
 
  // required .jaiabot.protobuf.Error error = 2;
  bool has_error() const;
  private:
  bool _internal_has_error() const;
  public:
  void clear_error();
  ::jaiabot::protobuf::Error error() const;
  void set_error(::jaiabot::protobuf::Error value);
  private:
  ::jaiabot::protobuf::Error _internal_error() const;
  void _internal_set_error(::jaiabot::protobuf::Error value);
  public:
 
  // @@protoc_insertion_point(class_scope:jaiabot.protobuf.SystemdStopReport)
 private:
  class _Internal;
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr journal_dump_file_;
    int result_;
    int error_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_jaiabot_2fmessages_2fhealth_2eproto;
};
// -------------------------------------------------------------------
 
class SystemdReportAck final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:jaiabot.protobuf.SystemdReportAck) */ {
 public:
  inline SystemdReportAck() : SystemdReportAck(nullptr) {}
  ~SystemdReportAck() override;
  explicit PROTOBUF_CONSTEXPR SystemdReportAck(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  SystemdReportAck(const SystemdReportAck& from);
  SystemdReportAck(SystemdReportAck&& from) noexcept
    : SystemdReportAck() {
    *this = ::std::move(from);
  }
 
  inline SystemdReportAck& operator=(const SystemdReportAck& from) {
    CopyFrom(from);
    return *this;
  }
  inline SystemdReportAck& operator=(SystemdReportAck&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SystemdReportAck& default_instance() {
    return *internal_default_instance();
  }
  static inline const SystemdReportAck* internal_default_instance() {
    return reinterpret_cast<const SystemdReportAck*>(
               &_SystemdReportAck_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;
 
  friend void swap(SystemdReportAck& a, SystemdReportAck& b) {
    a.Swap(&b);
  }
  inline void Swap(SystemdReportAck* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SystemdReportAck* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  SystemdReportAck* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SystemdReportAck>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SystemdReportAck& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SystemdReportAck& from) {
    SystemdReportAck::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SystemdReportAck* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "jaiabot.protobuf.SystemdReportAck";
  }
  protected:
  explicit SystemdReportAck(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kErrorAckFieldNumber = 1,
  };
  // required .jaiabot.protobuf.Error error_ack = 1;
  bool has_error_ack() const;
  private:
  bool _internal_has_error_ack() const;
  public:
  void clear_error_ack();
  ::jaiabot::protobuf::Error error_ack() const;
  void set_error_ack(::jaiabot::protobuf::Error value);
  private:
  ::jaiabot::protobuf::Error _internal_error_ack() const;
  void _internal_set_error_ack(::jaiabot::protobuf::Error value);
  public:
 
  // @@protoc_insertion_point(class_scope:jaiabot.protobuf.SystemdReportAck)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int error_ack_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_jaiabot_2fmessages_2fhealth_2eproto;
};
// ===================================================================
 
static const int kJaiabotThreadFieldNumber = 1000;
extern ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier< ::goby::middleware::protobuf::ThreadHealth,
    ::PROTOBUF_NAMESPACE_ID::internal::MessageTypeTraits< ::jaiabot::protobuf::ThreadHealth >, 11, false >
  jaiabot_thread;
static const int kJaiabotVehicleFieldNumber = 1000;
extern ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier< ::goby::middleware::protobuf::VehicleHealth,
    ::PROTOBUF_NAMESPACE_ID::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::_internal_has_one_min() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool LinuxHardwareStatus_Processor_LoadAverages::has_one_min() const {
  return _internal_has_one_min();
}
inline void LinuxHardwareStatus_Processor_LoadAverages::clear_one_min() {
  _impl_.one_min_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float LinuxHardwareStatus_Processor_LoadAverages::_internal_one_min() const {
  return _impl_.one_min_;
}
inline float LinuxHardwareStatus_Processor_LoadAverages::one_min() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.Processor.LoadAverages.one_min)
  return _internal_one_min();
}
inline void LinuxHardwareStatus_Processor_LoadAverages::_internal_set_one_min(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.one_min_ = value;
}
inline void LinuxHardwareStatus_Processor_LoadAverages::set_one_min(float value) {
  _internal_set_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::_internal_has_five_min() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool LinuxHardwareStatus_Processor_LoadAverages::has_five_min() const {
  return _internal_has_five_min();
}
inline void LinuxHardwareStatus_Processor_LoadAverages::clear_five_min() {
  _impl_.five_min_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float LinuxHardwareStatus_Processor_LoadAverages::_internal_five_min() const {
  return _impl_.five_min_;
}
inline float LinuxHardwareStatus_Processor_LoadAverages::five_min() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.Processor.LoadAverages.five_min)
  return _internal_five_min();
}
inline void LinuxHardwareStatus_Processor_LoadAverages::_internal_set_five_min(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.five_min_ = value;
}
inline void LinuxHardwareStatus_Processor_LoadAverages::set_five_min(float value) {
  _internal_set_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::_internal_has_fifteen_min() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool LinuxHardwareStatus_Processor_LoadAverages::has_fifteen_min() const {
  return _internal_has_fifteen_min();
}
inline void LinuxHardwareStatus_Processor_LoadAverages::clear_fifteen_min() {
  _impl_.fifteen_min_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float LinuxHardwareStatus_Processor_LoadAverages::_internal_fifteen_min() const {
  return _impl_.fifteen_min_;
}
inline float LinuxHardwareStatus_Processor_LoadAverages::fifteen_min() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.Processor.LoadAverages.fifteen_min)
  return _internal_fifteen_min();
}
inline void LinuxHardwareStatus_Processor_LoadAverages::_internal_set_fifteen_min(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.fifteen_min_ = value;
}
inline void LinuxHardwareStatus_Processor_LoadAverages::set_fifteen_min(float value) {
  _internal_set_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::_internal_has_loads() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.loads_ != nullptr);
  return value;
}
inline bool LinuxHardwareStatus_Processor::has_loads() const {
  return _internal_has_loads();
}
inline void LinuxHardwareStatus_Processor::clear_loads() {
  if (_impl_.loads_ != nullptr) _impl_.loads_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages& LinuxHardwareStatus_Processor::_internal_loads() const {
  const ::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages* p = _impl_.loads_;
  return p != nullptr ? *p : reinterpret_cast<const ::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages&>(
      ::jaiabot::protobuf::_LinuxHardwareStatus_Processor_LoadAverages_default_instance_);
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages& LinuxHardwareStatus_Processor::loads() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.Processor.loads)
  return _internal_loads();
}
inline void LinuxHardwareStatus_Processor::unsafe_arena_set_allocated_loads(
    ::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages* loads) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.loads_);
  }
  _impl_.loads_ = loads;
  if (loads) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:jaiabot.protobuf.LinuxHardwareStatus.Processor.loads)
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages* LinuxHardwareStatus_Processor::release_loads() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages* temp = _impl_.loads_;
  _impl_.loads_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages* LinuxHardwareStatus_Processor::unsafe_arena_release_loads() {
  // @@protoc_insertion_point(field_release:jaiabot.protobuf.LinuxHardwareStatus.Processor.loads)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages* temp = _impl_.loads_;
  _impl_.loads_ = nullptr;
  return temp;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages* LinuxHardwareStatus_Processor::_internal_mutable_loads() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.loads_ == nullptr) {
    auto* p = CreateMaybeMessage<::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages>(GetArenaForAllocation());
    _impl_.loads_ = p;
  }
  return _impl_.loads_;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages* LinuxHardwareStatus_Processor::mutable_loads() {
  ::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages* _msg = _internal_mutable_loads();
  // @@protoc_insertion_point(field_mutable:jaiabot.protobuf.LinuxHardwareStatus.Processor.loads)
  return _msg;
}
inline void LinuxHardwareStatus_Processor::set_allocated_loads(::jaiabot::protobuf::LinuxHardwareStatus_Processor_LoadAverages* loads) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.loads_;
  }
  if (loads) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(loads);
    if (message_arena != submessage_arena) {
      loads = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, loads, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.loads_ = loads;
  // @@protoc_insertion_point(field_set_allocated:jaiabot.protobuf.LinuxHardwareStatus.Processor.loads)
}
 
// optional int32 num_processes = 15;
inline bool LinuxHardwareStatus_Processor::_internal_has_num_processes() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool LinuxHardwareStatus_Processor::has_num_processes() const {
  return _internal_has_num_processes();
}
inline void LinuxHardwareStatus_Processor::clear_num_processes() {
  _impl_.num_processes_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t LinuxHardwareStatus_Processor::_internal_num_processes() const {
  return _impl_.num_processes_;
}
inline int32_t LinuxHardwareStatus_Processor::num_processes() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.Processor.num_processes)
  return _internal_num_processes();
}
inline void LinuxHardwareStatus_Processor::_internal_set_num_processes(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.num_processes_ = value;
}
inline void LinuxHardwareStatus_Processor::set_num_processes(int32_t value) {
  _internal_set_num_processes(value);
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.LinuxHardwareStatus.Processor.num_processes)
}
 
// optional int32 num_processors = 20;
inline bool LinuxHardwareStatus_Processor::_internal_has_num_processors() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool LinuxHardwareStatus_Processor::has_num_processors() const {
  return _internal_has_num_processors();
}
inline void LinuxHardwareStatus_Processor::clear_num_processors() {
  _impl_.num_processors_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t LinuxHardwareStatus_Processor::_internal_num_processors() const {
  return _impl_.num_processors_;
}
inline int32_t LinuxHardwareStatus_Processor::num_processors() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.Processor.num_processors)
  return _internal_num_processors();
}
inline void LinuxHardwareStatus_Processor::_internal_set_num_processors(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.num_processors_ = value;
}
inline void LinuxHardwareStatus_Processor::set_num_processors(int32_t value) {
  _internal_set_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::_internal_has_total() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool LinuxHardwareStatus_Information::has_total() const {
  return _internal_has_total();
}
inline void LinuxHardwareStatus_Information::clear_total() {
  _impl_.total_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t LinuxHardwareStatus_Information::_internal_total() const {
  return _impl_.total_;
}
inline uint64_t LinuxHardwareStatus_Information::total() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.Information.total)
  return _internal_total();
}
inline void LinuxHardwareStatus_Information::_internal_set_total(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.total_ = value;
}
inline void LinuxHardwareStatus_Information::set_total(uint64_t value) {
  _internal_set_total(value);
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.LinuxHardwareStatus.Information.total)
}
 
// required uint64 available = 2 [(.dccl.field) = {
inline bool LinuxHardwareStatus_Information::_internal_has_available() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool LinuxHardwareStatus_Information::has_available() const {
  return _internal_has_available();
}
inline void LinuxHardwareStatus_Information::clear_available() {
  _impl_.available_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t LinuxHardwareStatus_Information::_internal_available() const {
  return _impl_.available_;
}
inline uint64_t LinuxHardwareStatus_Information::available() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.Information.available)
  return _internal_available();
}
inline void LinuxHardwareStatus_Information::_internal_set_available(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.available_ = value;
}
inline void LinuxHardwareStatus_Information::set_available(uint64_t value) {
  _internal_set_available(value);
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.LinuxHardwareStatus.Information.available)
}
 
// required float use_percent = 3;
inline bool LinuxHardwareStatus_Information::_internal_has_use_percent() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool LinuxHardwareStatus_Information::has_use_percent() const {
  return _internal_has_use_percent();
}
inline void LinuxHardwareStatus_Information::clear_use_percent() {
  _impl_.use_percent_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float LinuxHardwareStatus_Information::_internal_use_percent() const {
  return _impl_.use_percent_;
}
inline float LinuxHardwareStatus_Information::use_percent() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.Information.use_percent)
  return _internal_use_percent();
}
inline void LinuxHardwareStatus_Information::_internal_set_use_percent(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.use_percent_ = value;
}
inline void LinuxHardwareStatus_Information::set_use_percent(float value) {
  _internal_set_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::_internal_has_ram() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.ram_ != nullptr);
  return value;
}
inline bool LinuxHardwareStatus_Memory::has_ram() const {
  return _internal_has_ram();
}
inline void LinuxHardwareStatus_Memory::clear_ram() {
  if (_impl_.ram_ != nullptr) _impl_.ram_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_Information& LinuxHardwareStatus_Memory::_internal_ram() const {
  const ::jaiabot::protobuf::LinuxHardwareStatus_Information* p = _impl_.ram_;
  return p != nullptr ? *p : reinterpret_cast<const ::jaiabot::protobuf::LinuxHardwareStatus_Information&>(
      ::jaiabot::protobuf::_LinuxHardwareStatus_Information_default_instance_);
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_Information& LinuxHardwareStatus_Memory::ram() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.Memory.ram)
  return _internal_ram();
}
inline void LinuxHardwareStatus_Memory::unsafe_arena_set_allocated_ram(
    ::jaiabot::protobuf::LinuxHardwareStatus_Information* ram) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.ram_);
  }
  _impl_.ram_ = ram;
  if (ram) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:jaiabot.protobuf.LinuxHardwareStatus.Memory.ram)
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Information* LinuxHardwareStatus_Memory::release_ram() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* temp = _impl_.ram_;
  _impl_.ram_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Information* LinuxHardwareStatus_Memory::unsafe_arena_release_ram() {
  // @@protoc_insertion_point(field_release:jaiabot.protobuf.LinuxHardwareStatus.Memory.ram)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* temp = _impl_.ram_;
  _impl_.ram_ = nullptr;
  return temp;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Information* LinuxHardwareStatus_Memory::_internal_mutable_ram() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.ram_ == nullptr) {
    auto* p = CreateMaybeMessage<::jaiabot::protobuf::LinuxHardwareStatus_Information>(GetArenaForAllocation());
    _impl_.ram_ = p;
  }
  return _impl_.ram_;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Information* LinuxHardwareStatus_Memory::mutable_ram() {
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* _msg = _internal_mutable_ram();
  // @@protoc_insertion_point(field_mutable:jaiabot.protobuf.LinuxHardwareStatus.Memory.ram)
  return _msg;
}
inline void LinuxHardwareStatus_Memory::set_allocated_ram(::jaiabot::protobuf::LinuxHardwareStatus_Information* ram) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.ram_;
  }
  if (ram) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(ram);
    if (message_arena != submessage_arena) {
      ram = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, ram, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.ram_ = ram;
  // @@protoc_insertion_point(field_set_allocated:jaiabot.protobuf.LinuxHardwareStatus.Memory.ram)
}
 
// required .jaiabot.protobuf.LinuxHardwareStatus.Information swap = 2;
inline bool LinuxHardwareStatus_Memory::_internal_has_swap() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.swap_ != nullptr);
  return value;
}
inline bool LinuxHardwareStatus_Memory::has_swap() const {
  return _internal_has_swap();
}
inline void LinuxHardwareStatus_Memory::clear_swap() {
  if (_impl_.swap_ != nullptr) _impl_.swap_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_Information& LinuxHardwareStatus_Memory::_internal_swap() const {
  const ::jaiabot::protobuf::LinuxHardwareStatus_Information* p = _impl_.swap_;
  return p != nullptr ? *p : reinterpret_cast<const ::jaiabot::protobuf::LinuxHardwareStatus_Information&>(
      ::jaiabot::protobuf::_LinuxHardwareStatus_Information_default_instance_);
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_Information& LinuxHardwareStatus_Memory::swap() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.Memory.swap)
  return _internal_swap();
}
inline void LinuxHardwareStatus_Memory::unsafe_arena_set_allocated_swap(
    ::jaiabot::protobuf::LinuxHardwareStatus_Information* swap) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.swap_);
  }
  _impl_.swap_ = swap;
  if (swap) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:jaiabot.protobuf.LinuxHardwareStatus.Memory.swap)
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Information* LinuxHardwareStatus_Memory::release_swap() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* temp = _impl_.swap_;
  _impl_.swap_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Information* LinuxHardwareStatus_Memory::unsafe_arena_release_swap() {
  // @@protoc_insertion_point(field_release:jaiabot.protobuf.LinuxHardwareStatus.Memory.swap)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* temp = _impl_.swap_;
  _impl_.swap_ = nullptr;
  return temp;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Information* LinuxHardwareStatus_Memory::_internal_mutable_swap() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.swap_ == nullptr) {
    auto* p = CreateMaybeMessage<::jaiabot::protobuf::LinuxHardwareStatus_Information>(GetArenaForAllocation());
    _impl_.swap_ = p;
  }
  return _impl_.swap_;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Information* LinuxHardwareStatus_Memory::mutable_swap() {
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* _msg = _internal_mutable_swap();
  // @@protoc_insertion_point(field_mutable:jaiabot.protobuf.LinuxHardwareStatus.Memory.swap)
  return _msg;
}
inline void LinuxHardwareStatus_Memory::set_allocated_swap(::jaiabot::protobuf::LinuxHardwareStatus_Information* swap) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.swap_;
  }
  if (swap) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(swap);
    if (message_arena != submessage_arena) {
      swap = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, swap, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.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::_internal_has_rootfs() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.rootfs_ != nullptr);
  return value;
}
inline bool LinuxHardwareStatus_Disk::has_rootfs() const {
  return _internal_has_rootfs();
}
inline void LinuxHardwareStatus_Disk::clear_rootfs() {
  if (_impl_.rootfs_ != nullptr) _impl_.rootfs_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_Information& LinuxHardwareStatus_Disk::_internal_rootfs() const {
  const ::jaiabot::protobuf::LinuxHardwareStatus_Information* p = _impl_.rootfs_;
  return p != nullptr ? *p : reinterpret_cast<const ::jaiabot::protobuf::LinuxHardwareStatus_Information&>(
      ::jaiabot::protobuf::_LinuxHardwareStatus_Information_default_instance_);
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_Information& LinuxHardwareStatus_Disk::rootfs() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.Disk.rootfs)
  return _internal_rootfs();
}
inline void LinuxHardwareStatus_Disk::unsafe_arena_set_allocated_rootfs(
    ::jaiabot::protobuf::LinuxHardwareStatus_Information* rootfs) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.rootfs_);
  }
  _impl_.rootfs_ = rootfs;
  if (rootfs) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:jaiabot.protobuf.LinuxHardwareStatus.Disk.rootfs)
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Information* LinuxHardwareStatus_Disk::release_rootfs() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* temp = _impl_.rootfs_;
  _impl_.rootfs_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Information* LinuxHardwareStatus_Disk::unsafe_arena_release_rootfs() {
  // @@protoc_insertion_point(field_release:jaiabot.protobuf.LinuxHardwareStatus.Disk.rootfs)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* temp = _impl_.rootfs_;
  _impl_.rootfs_ = nullptr;
  return temp;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Information* LinuxHardwareStatus_Disk::_internal_mutable_rootfs() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.rootfs_ == nullptr) {
    auto* p = CreateMaybeMessage<::jaiabot::protobuf::LinuxHardwareStatus_Information>(GetArenaForAllocation());
    _impl_.rootfs_ = p;
  }
  return _impl_.rootfs_;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Information* LinuxHardwareStatus_Disk::mutable_rootfs() {
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* _msg = _internal_mutable_rootfs();
  // @@protoc_insertion_point(field_mutable:jaiabot.protobuf.LinuxHardwareStatus.Disk.rootfs)
  return _msg;
}
inline void LinuxHardwareStatus_Disk::set_allocated_rootfs(::jaiabot::protobuf::LinuxHardwareStatus_Information* rootfs) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.rootfs_;
  }
  if (rootfs) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(rootfs);
    if (message_arena != submessage_arena) {
      rootfs = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, rootfs, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.rootfs_ = rootfs;
  // @@protoc_insertion_point(field_set_allocated:jaiabot.protobuf.LinuxHardwareStatus.Disk.rootfs)
}
 
// optional .jaiabot.protobuf.LinuxHardwareStatus.Information data = 2;
inline bool LinuxHardwareStatus_Disk::_internal_has_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.data_ != nullptr);
  return value;
}
inline bool LinuxHardwareStatus_Disk::has_data() const {
  return _internal_has_data();
}
inline void LinuxHardwareStatus_Disk::clear_data() {
  if (_impl_.data_ != nullptr) _impl_.data_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_Information& LinuxHardwareStatus_Disk::_internal_data() const {
  const ::jaiabot::protobuf::LinuxHardwareStatus_Information* p = _impl_.data_;
  return p != nullptr ? *p : reinterpret_cast<const ::jaiabot::protobuf::LinuxHardwareStatus_Information&>(
      ::jaiabot::protobuf::_LinuxHardwareStatus_Information_default_instance_);
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_Information& LinuxHardwareStatus_Disk::data() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.Disk.data)
  return _internal_data();
}
inline void LinuxHardwareStatus_Disk::unsafe_arena_set_allocated_data(
    ::jaiabot::protobuf::LinuxHardwareStatus_Information* data) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.data_);
  }
  _impl_.data_ = data;
  if (data) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:jaiabot.protobuf.LinuxHardwareStatus.Disk.data)
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Information* LinuxHardwareStatus_Disk::release_data() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* temp = _impl_.data_;
  _impl_.data_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Information* LinuxHardwareStatus_Disk::unsafe_arena_release_data() {
  // @@protoc_insertion_point(field_release:jaiabot.protobuf.LinuxHardwareStatus.Disk.data)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* temp = _impl_.data_;
  _impl_.data_ = nullptr;
  return temp;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Information* LinuxHardwareStatus_Disk::_internal_mutable_data() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.data_ == nullptr) {
    auto* p = CreateMaybeMessage<::jaiabot::protobuf::LinuxHardwareStatus_Information>(GetArenaForAllocation());
    _impl_.data_ = p;
  }
  return _impl_.data_;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Information* LinuxHardwareStatus_Disk::mutable_data() {
  ::jaiabot::protobuf::LinuxHardwareStatus_Information* _msg = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:jaiabot.protobuf.LinuxHardwareStatus.Disk.data)
  return _msg;
}
inline void LinuxHardwareStatus_Disk::set_allocated_data(::jaiabot::protobuf::LinuxHardwareStatus_Information* data) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.data_;
  }
  if (data) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(data);
    if (message_arena != submessage_arena) {
      data = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, data, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.data_ = data;
  // @@protoc_insertion_point(field_set_allocated:jaiabot.protobuf.LinuxHardwareStatus.Disk.data)
}
 
// -------------------------------------------------------------------
 
// LinuxHardwareStatus_WiFi
 
// required bool is_connected = 1;
inline bool LinuxHardwareStatus_WiFi::_internal_has_is_connected() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool LinuxHardwareStatus_WiFi::has_is_connected() const {
  return _internal_has_is_connected();
}
inline void LinuxHardwareStatus_WiFi::clear_is_connected() {
  _impl_.is_connected_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool LinuxHardwareStatus_WiFi::_internal_is_connected() const {
  return _impl_.is_connected_;
}
inline bool LinuxHardwareStatus_WiFi::is_connected() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.WiFi.is_connected)
  return _internal_is_connected();
}
inline void LinuxHardwareStatus_WiFi::_internal_set_is_connected(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.is_connected_ = value;
}
inline void LinuxHardwareStatus_WiFi::set_is_connected(bool value) {
  _internal_set_is_connected(value);
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.LinuxHardwareStatus.WiFi.is_connected)
}
 
// optional uint32 link_quality = 2;
inline bool LinuxHardwareStatus_WiFi::_internal_has_link_quality() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool LinuxHardwareStatus_WiFi::has_link_quality() const {
  return _internal_has_link_quality();
}
inline void LinuxHardwareStatus_WiFi::clear_link_quality() {
  _impl_.link_quality_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t LinuxHardwareStatus_WiFi::_internal_link_quality() const {
  return _impl_.link_quality_;
}
inline uint32_t LinuxHardwareStatus_WiFi::link_quality() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.WiFi.link_quality)
  return _internal_link_quality();
}
inline void LinuxHardwareStatus_WiFi::_internal_set_link_quality(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.link_quality_ = value;
}
inline void LinuxHardwareStatus_WiFi::set_link_quality(uint32_t value) {
  _internal_set_link_quality(value);
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.LinuxHardwareStatus.WiFi.link_quality)
}
 
// optional uint32 link_quality_percentage = 3;
inline bool LinuxHardwareStatus_WiFi::_internal_has_link_quality_percentage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool LinuxHardwareStatus_WiFi::has_link_quality_percentage() const {
  return _internal_has_link_quality_percentage();
}
inline void LinuxHardwareStatus_WiFi::clear_link_quality_percentage() {
  _impl_.link_quality_percentage_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t LinuxHardwareStatus_WiFi::_internal_link_quality_percentage() const {
  return _impl_.link_quality_percentage_;
}
inline uint32_t LinuxHardwareStatus_WiFi::link_quality_percentage() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.WiFi.link_quality_percentage)
  return _internal_link_quality_percentage();
}
inline void LinuxHardwareStatus_WiFi::_internal_set_link_quality_percentage(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.link_quality_percentage_ = value;
}
inline void LinuxHardwareStatus_WiFi::set_link_quality_percentage(uint32_t value) {
  _internal_set_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::_internal_has_signal_level() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool LinuxHardwareStatus_WiFi::has_signal_level() const {
  return _internal_has_signal_level();
}
inline void LinuxHardwareStatus_WiFi::clear_signal_level() {
  _impl_.signal_level_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t LinuxHardwareStatus_WiFi::_internal_signal_level() const {
  return _impl_.signal_level_;
}
inline int32_t LinuxHardwareStatus_WiFi::signal_level() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.WiFi.signal_level)
  return _internal_signal_level();
}
inline void LinuxHardwareStatus_WiFi::_internal_set_signal_level(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.signal_level_ = value;
}
inline void LinuxHardwareStatus_WiFi::set_signal_level(int32_t value) {
  _internal_set_signal_level(value);
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.LinuxHardwareStatus.WiFi.signal_level)
}
 
// optional int32 noise_level = 5;
inline bool LinuxHardwareStatus_WiFi::_internal_has_noise_level() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool LinuxHardwareStatus_WiFi::has_noise_level() const {
  return _internal_has_noise_level();
}
inline void LinuxHardwareStatus_WiFi::clear_noise_level() {
  _impl_.noise_level_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t LinuxHardwareStatus_WiFi::_internal_noise_level() const {
  return _impl_.noise_level_;
}
inline int32_t LinuxHardwareStatus_WiFi::noise_level() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.WiFi.noise_level)
  return _internal_noise_level();
}
inline void LinuxHardwareStatus_WiFi::_internal_set_noise_level(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.noise_level_ = value;
}
inline void LinuxHardwareStatus_WiFi::set_noise_level(int32_t value) {
  _internal_set_noise_level(value);
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.LinuxHardwareStatus.WiFi.noise_level)
}
 
// -------------------------------------------------------------------
 
// LinuxHardwareStatus
 
// optional int32 uptime = 10 [(.dccl.field) = {
inline bool LinuxHardwareStatus::_internal_has_uptime() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool LinuxHardwareStatus::has_uptime() const {
  return _internal_has_uptime();
}
inline void LinuxHardwareStatus::clear_uptime() {
  _impl_.uptime_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t LinuxHardwareStatus::_internal_uptime() const {
  return _impl_.uptime_;
}
inline int32_t LinuxHardwareStatus::uptime() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.uptime)
  return _internal_uptime();
}
inline void LinuxHardwareStatus::_internal_set_uptime(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.uptime_ = value;
}
inline void LinuxHardwareStatus::set_uptime(int32_t value) {
  _internal_set_uptime(value);
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.LinuxHardwareStatus.uptime)
}
 
// optional .jaiabot.protobuf.LinuxHardwareStatus.Processor processor = 20;
inline bool LinuxHardwareStatus::_internal_has_processor() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.processor_ != nullptr);
  return value;
}
inline bool LinuxHardwareStatus::has_processor() const {
  return _internal_has_processor();
}
inline void LinuxHardwareStatus::clear_processor() {
  if (_impl_.processor_ != nullptr) _impl_.processor_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_Processor& LinuxHardwareStatus::_internal_processor() const {
  const ::jaiabot::protobuf::LinuxHardwareStatus_Processor* p = _impl_.processor_;
  return p != nullptr ? *p : reinterpret_cast<const ::jaiabot::protobuf::LinuxHardwareStatus_Processor&>(
      ::jaiabot::protobuf::_LinuxHardwareStatus_Processor_default_instance_);
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_Processor& LinuxHardwareStatus::processor() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.processor)
  return _internal_processor();
}
inline void LinuxHardwareStatus::unsafe_arena_set_allocated_processor(
    ::jaiabot::protobuf::LinuxHardwareStatus_Processor* processor) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.processor_);
  }
  _impl_.processor_ = processor;
  if (processor) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:jaiabot.protobuf.LinuxHardwareStatus.processor)
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Processor* LinuxHardwareStatus::release_processor() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::jaiabot::protobuf::LinuxHardwareStatus_Processor* temp = _impl_.processor_;
  _impl_.processor_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Processor* LinuxHardwareStatus::unsafe_arena_release_processor() {
  // @@protoc_insertion_point(field_release:jaiabot.protobuf.LinuxHardwareStatus.processor)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::jaiabot::protobuf::LinuxHardwareStatus_Processor* temp = _impl_.processor_;
  _impl_.processor_ = nullptr;
  return temp;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Processor* LinuxHardwareStatus::_internal_mutable_processor() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.processor_ == nullptr) {
    auto* p = CreateMaybeMessage<::jaiabot::protobuf::LinuxHardwareStatus_Processor>(GetArenaForAllocation());
    _impl_.processor_ = p;
  }
  return _impl_.processor_;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Processor* LinuxHardwareStatus::mutable_processor() {
  ::jaiabot::protobuf::LinuxHardwareStatus_Processor* _msg = _internal_mutable_processor();
  // @@protoc_insertion_point(field_mutable:jaiabot.protobuf.LinuxHardwareStatus.processor)
  return _msg;
}
inline void LinuxHardwareStatus::set_allocated_processor(::jaiabot::protobuf::LinuxHardwareStatus_Processor* processor) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.processor_;
  }
  if (processor) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(processor);
    if (message_arena != submessage_arena) {
      processor = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, processor, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.processor_ = processor;
  // @@protoc_insertion_point(field_set_allocated:jaiabot.protobuf.LinuxHardwareStatus.processor)
}
 
// optional .jaiabot.protobuf.LinuxHardwareStatus.Memory memory = 30;
inline bool LinuxHardwareStatus::_internal_has_memory() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.memory_ != nullptr);
  return value;
}
inline bool LinuxHardwareStatus::has_memory() const {
  return _internal_has_memory();
}
inline void LinuxHardwareStatus::clear_memory() {
  if (_impl_.memory_ != nullptr) _impl_.memory_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_Memory& LinuxHardwareStatus::_internal_memory() const {
  const ::jaiabot::protobuf::LinuxHardwareStatus_Memory* p = _impl_.memory_;
  return p != nullptr ? *p : reinterpret_cast<const ::jaiabot::protobuf::LinuxHardwareStatus_Memory&>(
      ::jaiabot::protobuf::_LinuxHardwareStatus_Memory_default_instance_);
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_Memory& LinuxHardwareStatus::memory() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.memory)
  return _internal_memory();
}
inline void LinuxHardwareStatus::unsafe_arena_set_allocated_memory(
    ::jaiabot::protobuf::LinuxHardwareStatus_Memory* memory) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.memory_);
  }
  _impl_.memory_ = memory;
  if (memory) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:jaiabot.protobuf.LinuxHardwareStatus.memory)
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Memory* LinuxHardwareStatus::release_memory() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::jaiabot::protobuf::LinuxHardwareStatus_Memory* temp = _impl_.memory_;
  _impl_.memory_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Memory* LinuxHardwareStatus::unsafe_arena_release_memory() {
  // @@protoc_insertion_point(field_release:jaiabot.protobuf.LinuxHardwareStatus.memory)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::jaiabot::protobuf::LinuxHardwareStatus_Memory* temp = _impl_.memory_;
  _impl_.memory_ = nullptr;
  return temp;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Memory* LinuxHardwareStatus::_internal_mutable_memory() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.memory_ == nullptr) {
    auto* p = CreateMaybeMessage<::jaiabot::protobuf::LinuxHardwareStatus_Memory>(GetArenaForAllocation());
    _impl_.memory_ = p;
  }
  return _impl_.memory_;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Memory* LinuxHardwareStatus::mutable_memory() {
  ::jaiabot::protobuf::LinuxHardwareStatus_Memory* _msg = _internal_mutable_memory();
  // @@protoc_insertion_point(field_mutable:jaiabot.protobuf.LinuxHardwareStatus.memory)
  return _msg;
}
inline void LinuxHardwareStatus::set_allocated_memory(::jaiabot::protobuf::LinuxHardwareStatus_Memory* memory) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.memory_;
  }
  if (memory) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(memory);
    if (message_arena != submessage_arena) {
      memory = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, memory, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.memory_ = memory;
  // @@protoc_insertion_point(field_set_allocated:jaiabot.protobuf.LinuxHardwareStatus.memory)
}
 
// optional .jaiabot.protobuf.LinuxHardwareStatus.Disk disk = 40;
inline bool LinuxHardwareStatus::_internal_has_disk() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.disk_ != nullptr);
  return value;
}
inline bool LinuxHardwareStatus::has_disk() const {
  return _internal_has_disk();
}
inline void LinuxHardwareStatus::clear_disk() {
  if (_impl_.disk_ != nullptr) _impl_.disk_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_Disk& LinuxHardwareStatus::_internal_disk() const {
  const ::jaiabot::protobuf::LinuxHardwareStatus_Disk* p = _impl_.disk_;
  return p != nullptr ? *p : reinterpret_cast<const ::jaiabot::protobuf::LinuxHardwareStatus_Disk&>(
      ::jaiabot::protobuf::_LinuxHardwareStatus_Disk_default_instance_);
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_Disk& LinuxHardwareStatus::disk() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.disk)
  return _internal_disk();
}
inline void LinuxHardwareStatus::unsafe_arena_set_allocated_disk(
    ::jaiabot::protobuf::LinuxHardwareStatus_Disk* disk) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.disk_);
  }
  _impl_.disk_ = disk;
  if (disk) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:jaiabot.protobuf.LinuxHardwareStatus.disk)
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Disk* LinuxHardwareStatus::release_disk() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::jaiabot::protobuf::LinuxHardwareStatus_Disk* temp = _impl_.disk_;
  _impl_.disk_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Disk* LinuxHardwareStatus::unsafe_arena_release_disk() {
  // @@protoc_insertion_point(field_release:jaiabot.protobuf.LinuxHardwareStatus.disk)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::jaiabot::protobuf::LinuxHardwareStatus_Disk* temp = _impl_.disk_;
  _impl_.disk_ = nullptr;
  return temp;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Disk* LinuxHardwareStatus::_internal_mutable_disk() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.disk_ == nullptr) {
    auto* p = CreateMaybeMessage<::jaiabot::protobuf::LinuxHardwareStatus_Disk>(GetArenaForAllocation());
    _impl_.disk_ = p;
  }
  return _impl_.disk_;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_Disk* LinuxHardwareStatus::mutable_disk() {
  ::jaiabot::protobuf::LinuxHardwareStatus_Disk* _msg = _internal_mutable_disk();
  // @@protoc_insertion_point(field_mutable:jaiabot.protobuf.LinuxHardwareStatus.disk)
  return _msg;
}
inline void LinuxHardwareStatus::set_allocated_disk(::jaiabot::protobuf::LinuxHardwareStatus_Disk* disk) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.disk_;
  }
  if (disk) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(disk);
    if (message_arena != submessage_arena) {
      disk = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, disk, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.disk_ = disk;
  // @@protoc_insertion_point(field_set_allocated:jaiabot.protobuf.LinuxHardwareStatus.disk)
}
 
// optional .jaiabot.protobuf.LinuxHardwareStatus.WiFi wifi = 50;
inline bool LinuxHardwareStatus::_internal_has_wifi() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.wifi_ != nullptr);
  return value;
}
inline bool LinuxHardwareStatus::has_wifi() const {
  return _internal_has_wifi();
}
inline void LinuxHardwareStatus::clear_wifi() {
  if (_impl_.wifi_ != nullptr) _impl_.wifi_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_WiFi& LinuxHardwareStatus::_internal_wifi() const {
  const ::jaiabot::protobuf::LinuxHardwareStatus_WiFi* p = _impl_.wifi_;
  return p != nullptr ? *p : reinterpret_cast<const ::jaiabot::protobuf::LinuxHardwareStatus_WiFi&>(
      ::jaiabot::protobuf::_LinuxHardwareStatus_WiFi_default_instance_);
}
inline const ::jaiabot::protobuf::LinuxHardwareStatus_WiFi& LinuxHardwareStatus::wifi() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.LinuxHardwareStatus.wifi)
  return _internal_wifi();
}
inline void LinuxHardwareStatus::unsafe_arena_set_allocated_wifi(
    ::jaiabot::protobuf::LinuxHardwareStatus_WiFi* wifi) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.wifi_);
  }
  _impl_.wifi_ = wifi;
  if (wifi) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:jaiabot.protobuf.LinuxHardwareStatus.wifi)
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_WiFi* LinuxHardwareStatus::release_wifi() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::jaiabot::protobuf::LinuxHardwareStatus_WiFi* temp = _impl_.wifi_;
  _impl_.wifi_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_WiFi* LinuxHardwareStatus::unsafe_arena_release_wifi() {
  // @@protoc_insertion_point(field_release:jaiabot.protobuf.LinuxHardwareStatus.wifi)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::jaiabot::protobuf::LinuxHardwareStatus_WiFi* temp = _impl_.wifi_;
  _impl_.wifi_ = nullptr;
  return temp;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_WiFi* LinuxHardwareStatus::_internal_mutable_wifi() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.wifi_ == nullptr) {
    auto* p = CreateMaybeMessage<::jaiabot::protobuf::LinuxHardwareStatus_WiFi>(GetArenaForAllocation());
    _impl_.wifi_ = p;
  }
  return _impl_.wifi_;
}
inline ::jaiabot::protobuf::LinuxHardwareStatus_WiFi* LinuxHardwareStatus::mutable_wifi() {
  ::jaiabot::protobuf::LinuxHardwareStatus_WiFi* _msg = _internal_mutable_wifi();
  // @@protoc_insertion_point(field_mutable:jaiabot.protobuf.LinuxHardwareStatus.wifi)
  return _msg;
}
inline void LinuxHardwareStatus::set_allocated_wifi(::jaiabot::protobuf::LinuxHardwareStatus_WiFi* wifi) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.wifi_;
  }
  if (wifi) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(wifi);
    if (message_arena != submessage_arena) {
      wifi = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, wifi, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.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::_internal_has_tally_code() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool NTPStatus_NTPPeer::has_tally_code() const {
  return _internal_has_tally_code();
}
inline void NTPStatus_NTPPeer::clear_tally_code() {
  _impl_.tally_code_ = -1;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline ::jaiabot::protobuf::NTPStatus_NTPPeer_TallyCode NTPStatus_NTPPeer::_internal_tally_code() const {
  return static_cast< ::jaiabot::protobuf::NTPStatus_NTPPeer_TallyCode >(_impl_.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 _internal_tally_code();
}
inline void NTPStatus_NTPPeer::_internal_set_tally_code(::jaiabot::protobuf::NTPStatus_NTPPeer_TallyCode value) {
  assert(::jaiabot::protobuf::NTPStatus_NTPPeer_TallyCode_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.tally_code_ = value;
}
inline void NTPStatus_NTPPeer::set_tally_code(::jaiabot::protobuf::NTPStatus_NTPPeer_TallyCode value) {
  _internal_set_tally_code(value);
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.NTPStatus.NTPPeer.tally_code)
}
 
// required string remote = 2;
inline bool NTPStatus_NTPPeer::_internal_has_remote() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool NTPStatus_NTPPeer::has_remote() const {
  return _internal_has_remote();
}
inline void NTPStatus_NTPPeer::clear_remote() {
  _impl_.remote_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& NTPStatus_NTPPeer::remote() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.NTPStatus.NTPPeer.remote)
  return _internal_remote();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void NTPStatus_NTPPeer::set_remote(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.remote_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.NTPStatus.NTPPeer.remote)
}
inline std::string* NTPStatus_NTPPeer::mutable_remote() {
  std::string* _s = _internal_mutable_remote();
  // @@protoc_insertion_point(field_mutable:jaiabot.protobuf.NTPStatus.NTPPeer.remote)
  return _s;
}
inline const std::string& NTPStatus_NTPPeer::_internal_remote() const {
  return _impl_.remote_.Get();
}
inline void NTPStatus_NTPPeer::_internal_set_remote(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.remote_.Set(value, GetArenaForAllocation());
}
inline std::string* NTPStatus_NTPPeer::_internal_mutable_remote() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.remote_.Mutable(GetArenaForAllocation());
}
inline std::string* NTPStatus_NTPPeer::release_remote() {
  // @@protoc_insertion_point(field_release:jaiabot.protobuf.NTPStatus.NTPPeer.remote)
  if (!_internal_has_remote()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.remote_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.remote_.IsDefault()) {
    _impl_.remote_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void NTPStatus_NTPPeer::set_allocated_remote(std::string* remote) {
  if (remote != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.remote_.SetAllocated(remote, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.remote_.IsDefault()) {
    _impl_.remote_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:jaiabot.protobuf.NTPStatus.NTPPeer.remote)
}
 
// required string refid = 3;
inline bool NTPStatus_NTPPeer::_internal_has_refid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool NTPStatus_NTPPeer::has_refid() const {
  return _internal_has_refid();
}
inline void NTPStatus_NTPPeer::clear_refid() {
  _impl_.refid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& NTPStatus_NTPPeer::refid() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.NTPStatus.NTPPeer.refid)
  return _internal_refid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void NTPStatus_NTPPeer::set_refid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.refid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.NTPStatus.NTPPeer.refid)
}
inline std::string* NTPStatus_NTPPeer::mutable_refid() {
  std::string* _s = _internal_mutable_refid();
  // @@protoc_insertion_point(field_mutable:jaiabot.protobuf.NTPStatus.NTPPeer.refid)
  return _s;
}
inline const std::string& NTPStatus_NTPPeer::_internal_refid() const {
  return _impl_.refid_.Get();
}
inline void NTPStatus_NTPPeer::_internal_set_refid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.refid_.Set(value, GetArenaForAllocation());
}
inline std::string* NTPStatus_NTPPeer::_internal_mutable_refid() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.refid_.Mutable(GetArenaForAllocation());
}
inline std::string* NTPStatus_NTPPeer::release_refid() {
  // @@protoc_insertion_point(field_release:jaiabot.protobuf.NTPStatus.NTPPeer.refid)
  if (!_internal_has_refid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.refid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.refid_.IsDefault()) {
    _impl_.refid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void NTPStatus_NTPPeer::set_allocated_refid(std::string* refid) {
  if (refid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.refid_.SetAllocated(refid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.refid_.IsDefault()) {
    _impl_.refid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:jaiabot.protobuf.NTPStatus.NTPPeer.refid)
}
 
// optional int32 stratum = 4 [default = 16];
inline bool NTPStatus_NTPPeer::_internal_has_stratum() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool NTPStatus_NTPPeer::has_stratum() const {
  return _internal_has_stratum();
}
inline void NTPStatus_NTPPeer::clear_stratum() {
  _impl_.stratum_ = 16;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t NTPStatus_NTPPeer::_internal_stratum() const {
  return _impl_.stratum_;
}
inline int32_t NTPStatus_NTPPeer::stratum() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.NTPStatus.NTPPeer.stratum)
  return _internal_stratum();
}
inline void NTPStatus_NTPPeer::_internal_set_stratum(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.stratum_ = value;
}
inline void NTPStatus_NTPPeer::set_stratum(int32_t value) {
  _internal_set_stratum(value);
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.NTPStatus.NTPPeer.stratum)
}
 
// optional int32 when = 5 [default = -1, (.dccl.field) = {
inline bool NTPStatus_NTPPeer::_internal_has_when() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool NTPStatus_NTPPeer::has_when() const {
  return _internal_has_when();
}
inline void NTPStatus_NTPPeer::clear_when() {
  _impl_.when_ = -1;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline int32_t NTPStatus_NTPPeer::_internal_when() const {
  return _impl_.when_;
}
inline int32_t NTPStatus_NTPPeer::when() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.NTPStatus.NTPPeer.when)
  return _internal_when();
}
inline void NTPStatus_NTPPeer::_internal_set_when(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.when_ = value;
}
inline void NTPStatus_NTPPeer::set_when(int32_t value) {
  _internal_set_when(value);
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.NTPStatus.NTPPeer.when)
}
 
// optional int32 poll = 6 [default = -1, (.dccl.field) = {
inline bool NTPStatus_NTPPeer::_internal_has_poll() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool NTPStatus_NTPPeer::has_poll() const {
  return _internal_has_poll();
}
inline void NTPStatus_NTPPeer::clear_poll() {
  _impl_.poll_ = -1;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline int32_t NTPStatus_NTPPeer::_internal_poll() const {
  return _impl_.poll_;
}
inline int32_t NTPStatus_NTPPeer::poll() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.NTPStatus.NTPPeer.poll)
  return _internal_poll();
}
inline void NTPStatus_NTPPeer::_internal_set_poll(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.poll_ = value;
}
inline void NTPStatus_NTPPeer::set_poll(int32_t value) {
  _internal_set_poll(value);
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.NTPStatus.NTPPeer.poll)
}
 
// optional int32 reach = 7 [default = 0];
inline bool NTPStatus_NTPPeer::_internal_has_reach() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool NTPStatus_NTPPeer::has_reach() const {
  return _internal_has_reach();
}
inline void NTPStatus_NTPPeer::clear_reach() {
  _impl_.reach_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t NTPStatus_NTPPeer::_internal_reach() const {
  return _impl_.reach_;
}
inline int32_t NTPStatus_NTPPeer::reach() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.NTPStatus.NTPPeer.reach)
  return _internal_reach();
}
inline void NTPStatus_NTPPeer::_internal_set_reach(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.reach_ = value;
}
inline void NTPStatus_NTPPeer::set_reach(int32_t value) {
  _internal_set_reach(value);
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.NTPStatus.NTPPeer.reach)
}
 
// optional float delay = 8 [default = nan, (.dccl.field) = {
inline bool NTPStatus_NTPPeer::_internal_has_delay() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool NTPStatus_NTPPeer::has_delay() const {
  return _internal_has_delay();
}
inline void NTPStatus_NTPPeer::clear_delay() {
  _impl_.delay_ = std::numeric_limits<float>::quiet_NaN();
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline float NTPStatus_NTPPeer::_internal_delay() const {
  return _impl_.delay_;
}
inline float NTPStatus_NTPPeer::delay() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.NTPStatus.NTPPeer.delay)
  return _internal_delay();
}
inline void NTPStatus_NTPPeer::_internal_set_delay(float value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.delay_ = value;
}
inline void NTPStatus_NTPPeer::set_delay(float value) {
  _internal_set_delay(value);
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.NTPStatus.NTPPeer.delay)
}
 
// optional float offset = 9 [default = nan, (.dccl.field) = {
inline bool NTPStatus_NTPPeer::_internal_has_offset() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool NTPStatus_NTPPeer::has_offset() const {
  return _internal_has_offset();
}
inline void NTPStatus_NTPPeer::clear_offset() {
  _impl_.offset_ = std::numeric_limits<float>::quiet_NaN();
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline float NTPStatus_NTPPeer::_internal_offset() const {
  return _impl_.offset_;
}
inline float NTPStatus_NTPPeer::offset() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.NTPStatus.NTPPeer.offset)
  return _internal_offset();
}
inline void NTPStatus_NTPPeer::_internal_set_offset(float value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.offset_ = value;
}
inline void NTPStatus_NTPPeer::set_offset(float value) {
  _internal_set_offset(value);
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.NTPStatus.NTPPeer.offset)
}
 
// optional float jitter = 10 [default = nan, (.dccl.field) = {
inline bool NTPStatus_NTPPeer::_internal_has_jitter() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool NTPStatus_NTPPeer::has_jitter() const {
  return _internal_has_jitter();
}
inline void NTPStatus_NTPPeer::clear_jitter() {
  _impl_.jitter_ = std::numeric_limits<float>::quiet_NaN();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline float NTPStatus_NTPPeer::_internal_jitter() const {
  return _impl_.jitter_;
}
inline float NTPStatus_NTPPeer::jitter() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.NTPStatus.NTPPeer.jitter)
  return _internal_jitter();
}
inline void NTPStatus_NTPPeer::_internal_set_jitter(float value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.jitter_ = value;
}
inline void NTPStatus_NTPPeer::set_jitter(float value) {
  _internal_set_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::_internal_has_sync_source() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool NTPStatus::has_sync_source() const {
  return _internal_has_sync_source();
}
inline void NTPStatus::clear_sync_source() {
  _impl_.sync_source_ = -1;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline ::jaiabot::protobuf::NTPStatus_SyncSource NTPStatus::_internal_sync_source() const {
  return static_cast< ::jaiabot::protobuf::NTPStatus_SyncSource >(_impl_.sync_source_);
}
inline ::jaiabot::protobuf::NTPStatus_SyncSource NTPStatus::sync_source() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.NTPStatus.sync_source)
  return _internal_sync_source();
}
inline void NTPStatus::_internal_set_sync_source(::jaiabot::protobuf::NTPStatus_SyncSource value) {
  assert(::jaiabot::protobuf::NTPStatus_SyncSource_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.sync_source_ = value;
}
inline void NTPStatus::set_sync_source(::jaiabot::protobuf::NTPStatus_SyncSource value) {
  _internal_set_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::_internal_has_leap_indicator() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool NTPStatus::has_leap_indicator() const {
  return _internal_has_leap_indicator();
}
inline void NTPStatus::clear_leap_indicator() {
  _impl_.leap_indicator_ = -1;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline ::jaiabot::protobuf::NTPStatus_LeapIndicator NTPStatus::_internal_leap_indicator() const {
  return static_cast< ::jaiabot::protobuf::NTPStatus_LeapIndicator >(_impl_.leap_indicator_);
}
inline ::jaiabot::protobuf::NTPStatus_LeapIndicator NTPStatus::leap_indicator() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.NTPStatus.leap_indicator)
  return _internal_leap_indicator();
}
inline void NTPStatus::_internal_set_leap_indicator(::jaiabot::protobuf::NTPStatus_LeapIndicator value) {
  assert(::jaiabot::protobuf::NTPStatus_LeapIndicator_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.leap_indicator_ = value;
}
inline void NTPStatus::set_leap_indicator(::jaiabot::protobuf::NTPStatus_LeapIndicator value) {
  _internal_set_leap_indicator(value);
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.NTPStatus.leap_indicator)
}
 
// optional int32 system_event_counter = 12 [default = 0];
inline bool NTPStatus::_internal_has_system_event_counter() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool NTPStatus::has_system_event_counter() const {
  return _internal_has_system_event_counter();
}
inline void NTPStatus::clear_system_event_counter() {
  _impl_.system_event_counter_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t NTPStatus::_internal_system_event_counter() const {
  return _impl_.system_event_counter_;
}
inline int32_t NTPStatus::system_event_counter() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.NTPStatus.system_event_counter)
  return _internal_system_event_counter();
}
inline void NTPStatus::_internal_set_system_event_counter(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.system_event_counter_ = value;
}
inline void NTPStatus::set_system_event_counter(int32_t value) {
  _internal_set_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::_internal_has_last_system_event() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool NTPStatus::has_last_system_event() const {
  return _internal_has_last_system_event();
}
inline void NTPStatus::clear_last_system_event() {
  _impl_.last_system_event_ = -1;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::jaiabot::protobuf::NTPStatus_NTPSystemEvent NTPStatus::_internal_last_system_event() const {
  return static_cast< ::jaiabot::protobuf::NTPStatus_NTPSystemEvent >(_impl_.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 _internal_last_system_event();
}
inline void NTPStatus::_internal_set_last_system_event(::jaiabot::protobuf::NTPStatus_NTPSystemEvent value) {
  assert(::jaiabot::protobuf::NTPStatus_NTPSystemEvent_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.last_system_event_ = value;
}
inline void NTPStatus::set_last_system_event(::jaiabot::protobuf::NTPStatus_NTPSystemEvent value) {
  _internal_set_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::_internal_has_system_sync_peer() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.system_sync_peer_ != nullptr);
  return value;
}
inline bool NTPStatus::has_system_sync_peer() const {
  return _internal_has_system_sync_peer();
}
inline void NTPStatus::clear_system_sync_peer() {
  if (_impl_.system_sync_peer_ != nullptr) _impl_.system_sync_peer_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::jaiabot::protobuf::NTPStatus_NTPPeer& NTPStatus::_internal_system_sync_peer() const {
  const ::jaiabot::protobuf::NTPStatus_NTPPeer* p = _impl_.system_sync_peer_;
  return p != nullptr ? *p : reinterpret_cast<const ::jaiabot::protobuf::NTPStatus_NTPPeer&>(
      ::jaiabot::protobuf::_NTPStatus_NTPPeer_default_instance_);
}
inline const ::jaiabot::protobuf::NTPStatus_NTPPeer& NTPStatus::system_sync_peer() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.NTPStatus.system_sync_peer)
  return _internal_system_sync_peer();
}
inline void NTPStatus::unsafe_arena_set_allocated_system_sync_peer(
    ::jaiabot::protobuf::NTPStatus_NTPPeer* system_sync_peer) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.system_sync_peer_);
  }
  _impl_.system_sync_peer_ = system_sync_peer;
  if (system_sync_peer) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:jaiabot.protobuf.NTPStatus.system_sync_peer)
}
inline ::jaiabot::protobuf::NTPStatus_NTPPeer* NTPStatus::release_system_sync_peer() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::jaiabot::protobuf::NTPStatus_NTPPeer* temp = _impl_.system_sync_peer_;
  _impl_.system_sync_peer_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::jaiabot::protobuf::NTPStatus_NTPPeer* NTPStatus::unsafe_arena_release_system_sync_peer() {
  // @@protoc_insertion_point(field_release:jaiabot.protobuf.NTPStatus.system_sync_peer)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::jaiabot::protobuf::NTPStatus_NTPPeer* temp = _impl_.system_sync_peer_;
  _impl_.system_sync_peer_ = nullptr;
  return temp;
}
inline ::jaiabot::protobuf::NTPStatus_NTPPeer* NTPStatus::_internal_mutable_system_sync_peer() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.system_sync_peer_ == nullptr) {
    auto* p = CreateMaybeMessage<::jaiabot::protobuf::NTPStatus_NTPPeer>(GetArenaForAllocation());
    _impl_.system_sync_peer_ = p;
  }
  return _impl_.system_sync_peer_;
}
inline ::jaiabot::protobuf::NTPStatus_NTPPeer* NTPStatus::mutable_system_sync_peer() {
  ::jaiabot::protobuf::NTPStatus_NTPPeer* _msg = _internal_mutable_system_sync_peer();
  // @@protoc_insertion_point(field_mutable:jaiabot.protobuf.NTPStatus.system_sync_peer)
  return _msg;
}
inline void NTPStatus::set_allocated_system_sync_peer(::jaiabot::protobuf::NTPStatus_NTPPeer* system_sync_peer) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.system_sync_peer_;
  }
  if (system_sync_peer) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(system_sync_peer);
    if (message_arena != submessage_arena) {
      system_sync_peer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, system_sync_peer, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.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::_internal_peer_size() const {
  return _impl_.peer_.size();
}
inline int NTPStatus::peer_size() const {
  return _internal_peer_size();
}
inline void NTPStatus::clear_peer() {
  _impl_.peer_.Clear();
}
inline ::jaiabot::protobuf::NTPStatus_NTPPeer* NTPStatus::mutable_peer(int index) {
  // @@protoc_insertion_point(field_mutable:jaiabot.protobuf.NTPStatus.peer)
  return _impl_.peer_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::jaiabot::protobuf::NTPStatus_NTPPeer >*
NTPStatus::mutable_peer() {
  // @@protoc_insertion_point(field_mutable_list:jaiabot.protobuf.NTPStatus.peer)
  return &_impl_.peer_;
}
inline const ::jaiabot::protobuf::NTPStatus_NTPPeer& NTPStatus::_internal_peer(int index) const {
  return _impl_.peer_.Get(index);
}
inline const ::jaiabot::protobuf::NTPStatus_NTPPeer& NTPStatus::peer(int index) const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.NTPStatus.peer)
  return _internal_peer(index);
}
inline ::jaiabot::protobuf::NTPStatus_NTPPeer* NTPStatus::_internal_add_peer() {
  return _impl_.peer_.Add();
}
inline ::jaiabot::protobuf::NTPStatus_NTPPeer* NTPStatus::add_peer() {
  ::jaiabot::protobuf::NTPStatus_NTPPeer* _add = _internal_add_peer();
  // @@protoc_insertion_point(field_add:jaiabot.protobuf.NTPStatus.peer)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::jaiabot::protobuf::NTPStatus_NTPPeer >&
NTPStatus::peer() const {
  // @@protoc_insertion_point(field_list:jaiabot.protobuf.NTPStatus.peer)
  return _impl_.peer_;
}
 
// -------------------------------------------------------------------
 
// HelmIVPStatus
 
// optional string helm_ivp_state = 1 [default = "PARK"];
inline bool HelmIVPStatus::_internal_has_helm_ivp_state() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool HelmIVPStatus::has_helm_ivp_state() const {
  return _internal_has_helm_ivp_state();
}
inline void HelmIVPStatus::clear_helm_ivp_state() {
  _impl_.helm_ivp_state_.ClearToDefault(::jaiabot::protobuf::HelmIVPStatus::Impl_::_i_give_permission_to_break_this_code_default_helm_ivp_state_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& HelmIVPStatus::helm_ivp_state() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.HelmIVPStatus.helm_ivp_state)
  if (_impl_.helm_ivp_state_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_helm_ivp_state_.get();
  return _internal_helm_ivp_state();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HelmIVPStatus::set_helm_ivp_state(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.helm_ivp_state_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.HelmIVPStatus.helm_ivp_state)
}
inline std::string* HelmIVPStatus::mutable_helm_ivp_state() {
  std::string* _s = _internal_mutable_helm_ivp_state();
  // @@protoc_insertion_point(field_mutable:jaiabot.protobuf.HelmIVPStatus.helm_ivp_state)
  return _s;
}
inline const std::string& HelmIVPStatus::_internal_helm_ivp_state() const {
  return _impl_.helm_ivp_state_.Get();
}
inline void HelmIVPStatus::_internal_set_helm_ivp_state(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.helm_ivp_state_.Set(value, GetArenaForAllocation());
}
inline std::string* HelmIVPStatus::_internal_mutable_helm_ivp_state() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.helm_ivp_state_.Mutable(::jaiabot::protobuf::HelmIVPStatus::Impl_::_i_give_permission_to_break_this_code_default_helm_ivp_state_, GetArenaForAllocation());
}
inline std::string* HelmIVPStatus::release_helm_ivp_state() {
  // @@protoc_insertion_point(field_release:jaiabot.protobuf.HelmIVPStatus.helm_ivp_state)
  if (!_internal_has_helm_ivp_state()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.helm_ivp_state_.Release();
  return p;
}
inline void HelmIVPStatus::set_allocated_helm_ivp_state(std::string* helm_ivp_state) {
  if (helm_ivp_state != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.helm_ivp_state_.SetAllocated(helm_ivp_state, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:jaiabot.protobuf.HelmIVPStatus.helm_ivp_state)
}
 
// optional bool helm_ivp_desired_speed = 2 [default = false];
inline bool HelmIVPStatus::_internal_has_helm_ivp_desired_speed() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool HelmIVPStatus::has_helm_ivp_desired_speed() const {
  return _internal_has_helm_ivp_desired_speed();
}
inline void HelmIVPStatus::clear_helm_ivp_desired_speed() {
  _impl_.helm_ivp_desired_speed_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool HelmIVPStatus::_internal_helm_ivp_desired_speed() const {
  return _impl_.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 _internal_helm_ivp_desired_speed();
}
inline void HelmIVPStatus::_internal_set_helm_ivp_desired_speed(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.helm_ivp_desired_speed_ = value;
}
inline void HelmIVPStatus::set_helm_ivp_desired_speed(bool value) {
  _internal_set_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::_internal_has_helm_ivp_desired_heading() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool HelmIVPStatus::has_helm_ivp_desired_heading() const {
  return _internal_has_helm_ivp_desired_heading();
}
inline void HelmIVPStatus::clear_helm_ivp_desired_heading() {
  _impl_.helm_ivp_desired_heading_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool HelmIVPStatus::_internal_helm_ivp_desired_heading() const {
  return _impl_.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 _internal_helm_ivp_desired_heading();
}
inline void HelmIVPStatus::_internal_set_helm_ivp_desired_heading(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.helm_ivp_desired_heading_ = value;
}
inline void HelmIVPStatus::set_helm_ivp_desired_heading(bool value) {
  _internal_set_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::_internal_has_helm_ivp_desired_depth() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool HelmIVPStatus::has_helm_ivp_desired_depth() const {
  return _internal_has_helm_ivp_desired_depth();
}
inline void HelmIVPStatus::clear_helm_ivp_desired_depth() {
  _impl_.helm_ivp_desired_depth_ = false;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline bool HelmIVPStatus::_internal_helm_ivp_desired_depth() const {
  return _impl_.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 _internal_helm_ivp_desired_depth();
}
inline void HelmIVPStatus::_internal_set_helm_ivp_desired_depth(bool value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.helm_ivp_desired_depth_ = value;
}
inline void HelmIVPStatus::set_helm_ivp_desired_depth(bool value) {
  _internal_set_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::_internal_has_helm_ivp_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool HelmIVPStatus::has_helm_ivp_data() const {
  return _internal_has_helm_ivp_data();
}
inline void HelmIVPStatus::clear_helm_ivp_data() {
  _impl_.helm_ivp_data_ = false;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline bool HelmIVPStatus::_internal_helm_ivp_data() const {
  return _impl_.helm_ivp_data_;
}
inline bool HelmIVPStatus::helm_ivp_data() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.HelmIVPStatus.helm_ivp_data)
  return _internal_helm_ivp_data();
}
inline void HelmIVPStatus::_internal_set_helm_ivp_data(bool value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.helm_ivp_data_ = value;
}
inline void HelmIVPStatus::set_helm_ivp_data(bool value) {
  _internal_set_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::_internal_error_size() const {
  return _impl_.error_.size();
}
inline int ThreadHealth::error_size() const {
  return _internal_error_size();
}
inline void ThreadHealth::clear_error() {
  _impl_.error_.Clear();
}
inline ::jaiabot::protobuf::Error ThreadHealth::_internal_error(int index) const {
  return static_cast< ::jaiabot::protobuf::Error >(_impl_.error_.Get(index));
}
inline ::jaiabot::protobuf::Error ThreadHealth::error(int index) const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.ThreadHealth.error)
  return _internal_error(index);
}
inline void ThreadHealth::set_error(int index, ::jaiabot::protobuf::Error value) {
  assert(::jaiabot::protobuf::Error_IsValid(value));
  _impl_.error_.Set(index, value);
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.ThreadHealth.error)
}
inline void ThreadHealth::_internal_add_error(::jaiabot::protobuf::Error value) {
  assert(::jaiabot::protobuf::Error_IsValid(value));
  _impl_.error_.Add(value);
}
inline void ThreadHealth::add_error(::jaiabot::protobuf::Error value) {
  _internal_add_error(value);
  // @@protoc_insertion_point(field_add:jaiabot.protobuf.ThreadHealth.error)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
ThreadHealth::error() const {
  // @@protoc_insertion_point(field_list:jaiabot.protobuf.ThreadHealth.error)
  return _impl_.error_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
ThreadHealth::_internal_mutable_error() {
  return &_impl_.error_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
ThreadHealth::mutable_error() {
  // @@protoc_insertion_point(field_mutable_list:jaiabot.protobuf.ThreadHealth.error)
  return _internal_mutable_error();
}
 
// repeated .jaiabot.protobuf.Warning warning = 2;
inline int ThreadHealth::_internal_warning_size() const {
  return _impl_.warning_.size();
}
inline int ThreadHealth::warning_size() const {
  return _internal_warning_size();
}
inline void ThreadHealth::clear_warning() {
  _impl_.warning_.Clear();
}
inline ::jaiabot::protobuf::Warning ThreadHealth::_internal_warning(int index) const {
  return static_cast< ::jaiabot::protobuf::Warning >(_impl_.warning_.Get(index));
}
inline ::jaiabot::protobuf::Warning ThreadHealth::warning(int index) const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.ThreadHealth.warning)
  return _internal_warning(index);
}
inline void ThreadHealth::set_warning(int index, ::jaiabot::protobuf::Warning value) {
  assert(::jaiabot::protobuf::Warning_IsValid(value));
  _impl_.warning_.Set(index, value);
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.ThreadHealth.warning)
}
inline void ThreadHealth::_internal_add_warning(::jaiabot::protobuf::Warning value) {
  assert(::jaiabot::protobuf::Warning_IsValid(value));
  _impl_.warning_.Add(value);
}
inline void ThreadHealth::add_warning(::jaiabot::protobuf::Warning value) {
  _internal_add_warning(value);
  // @@protoc_insertion_point(field_add:jaiabot.protobuf.ThreadHealth.warning)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
ThreadHealth::warning() const {
  // @@protoc_insertion_point(field_list:jaiabot.protobuf.ThreadHealth.warning)
  return _impl_.warning_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
ThreadHealth::_internal_mutable_warning() {
  return &_impl_.warning_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
ThreadHealth::mutable_warning() {
  // @@protoc_insertion_point(field_mutable_list:jaiabot.protobuf.ThreadHealth.warning)
  return _internal_mutable_warning();
}
 
// -------------------------------------------------------------------
 
// VehicleHealth
 
// -------------------------------------------------------------------
 
// SystemdStartReport
 
// required .jaiabot.protobuf.Error clear_error = 1;
inline bool SystemdStartReport::_internal_has_clear_error() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SystemdStartReport::has_clear_error() const {
  return _internal_has_clear_error();
}
inline void SystemdStartReport::clear_clear_error() {
  _impl_.clear_error_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline ::jaiabot::protobuf::Error SystemdStartReport::_internal_clear_error() const {
  return static_cast< ::jaiabot::protobuf::Error >(_impl_.clear_error_);
}
inline ::jaiabot::protobuf::Error SystemdStartReport::clear_error() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.SystemdStartReport.clear_error)
  return _internal_clear_error();
}
inline void SystemdStartReport::_internal_set_clear_error(::jaiabot::protobuf::Error value) {
  assert(::jaiabot::protobuf::Error_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.clear_error_ = value;
}
inline void SystemdStartReport::set_clear_error(::jaiabot::protobuf::Error value) {
  _internal_set_clear_error(value);
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.SystemdStartReport.clear_error)
}
 
// -------------------------------------------------------------------
 
// SystemdStopReport
 
// required .jaiabot.protobuf.SystemdStopReport.ServiceResult result = 1;
inline bool SystemdStopReport::_internal_has_result() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SystemdStopReport::has_result() const {
  return _internal_has_result();
}
inline void SystemdStopReport::clear_result() {
  _impl_.result_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::jaiabot::protobuf::SystemdStopReport_ServiceResult SystemdStopReport::_internal_result() const {
  return static_cast< ::jaiabot::protobuf::SystemdStopReport_ServiceResult >(_impl_.result_);
}
inline ::jaiabot::protobuf::SystemdStopReport_ServiceResult SystemdStopReport::result() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.SystemdStopReport.result)
  return _internal_result();
}
inline void SystemdStopReport::_internal_set_result(::jaiabot::protobuf::SystemdStopReport_ServiceResult value) {
  assert(::jaiabot::protobuf::SystemdStopReport_ServiceResult_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.result_ = value;
}
inline void SystemdStopReport::set_result(::jaiabot::protobuf::SystemdStopReport_ServiceResult value) {
  _internal_set_result(value);
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.SystemdStopReport.result)
}
 
// required .jaiabot.protobuf.Error error = 2;
inline bool SystemdStopReport::_internal_has_error() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SystemdStopReport::has_error() const {
  return _internal_has_error();
}
inline void SystemdStopReport::clear_error() {
  _impl_.error_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::jaiabot::protobuf::Error SystemdStopReport::_internal_error() const {
  return static_cast< ::jaiabot::protobuf::Error >(_impl_.error_);
}
inline ::jaiabot::protobuf::Error SystemdStopReport::error() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.SystemdStopReport.error)
  return _internal_error();
}
inline void SystemdStopReport::_internal_set_error(::jaiabot::protobuf::Error value) {
  assert(::jaiabot::protobuf::Error_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.error_ = value;
}
inline void SystemdStopReport::set_error(::jaiabot::protobuf::Error value) {
  _internal_set_error(value);
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.SystemdStopReport.error)
}
 
// optional string journal_dump_file = 3;
inline bool SystemdStopReport::_internal_has_journal_dump_file() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SystemdStopReport::has_journal_dump_file() const {
  return _internal_has_journal_dump_file();
}
inline void SystemdStopReport::clear_journal_dump_file() {
  _impl_.journal_dump_file_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SystemdStopReport::journal_dump_file() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.SystemdStopReport.journal_dump_file)
  return _internal_journal_dump_file();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemdStopReport::set_journal_dump_file(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.journal_dump_file_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:jaiabot.protobuf.SystemdStopReport.journal_dump_file)
}
inline std::string* SystemdStopReport::mutable_journal_dump_file() {
  std::string* _s = _internal_mutable_journal_dump_file();
  // @@protoc_insertion_point(field_mutable:jaiabot.protobuf.SystemdStopReport.journal_dump_file)
  return _s;
}
inline const std::string& SystemdStopReport::_internal_journal_dump_file() const {
  return _impl_.journal_dump_file_.Get();
}
inline void SystemdStopReport::_internal_set_journal_dump_file(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.journal_dump_file_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemdStopReport::_internal_mutable_journal_dump_file() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.journal_dump_file_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemdStopReport::release_journal_dump_file() {
  // @@protoc_insertion_point(field_release:jaiabot.protobuf.SystemdStopReport.journal_dump_file)
  if (!_internal_has_journal_dump_file()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.journal_dump_file_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.journal_dump_file_.IsDefault()) {
    _impl_.journal_dump_file_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemdStopReport::set_allocated_journal_dump_file(std::string* journal_dump_file) {
  if (journal_dump_file != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.journal_dump_file_.SetAllocated(journal_dump_file, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.journal_dump_file_.IsDefault()) {
    _impl_.journal_dump_file_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:jaiabot.protobuf.SystemdStopReport.journal_dump_file)
}
 
// -------------------------------------------------------------------
 
// SystemdReportAck
 
// required .jaiabot.protobuf.Error error_ack = 1;
inline bool SystemdReportAck::_internal_has_error_ack() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SystemdReportAck::has_error_ack() const {
  return _internal_has_error_ack();
}
inline void SystemdReportAck::clear_error_ack() {
  _impl_.error_ack_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline ::jaiabot::protobuf::Error SystemdReportAck::_internal_error_ack() const {
  return static_cast< ::jaiabot::protobuf::Error >(_impl_.error_ack_);
}
inline ::jaiabot::protobuf::Error SystemdReportAck::error_ack() const {
  // @@protoc_insertion_point(field_get:jaiabot.protobuf.SystemdReportAck.error_ack)
  return _internal_error_ack();
}
inline void SystemdReportAck::_internal_set_error_ack(::jaiabot::protobuf::Error value) {
  assert(::jaiabot::protobuf::Error_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.error_ack_ = value;
}
inline void SystemdReportAck::set_error_ack(::jaiabot::protobuf::Error value) {
  _internal_set_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
 
PROTOBUF_NAMESPACE_OPEN
 
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();
}
 
PROTOBUF_NAMESPACE_CLOSE
 
// @@protoc_insertion_point(global_scope)
 
#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_jaiabot_2fmessages_2fhealth_2eproto