nearby/compiled_proto/proto/errorcode/error_code_enums.pb.cc

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: proto/errorcode/error_code_enums.proto

#include "proto/errorcode/error_code_enums.pb.h"

#include <algorithm>

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>

PROTOBUF_PRAGMA_INIT_SEG
namespace location {
namespace nearby {
namespace errorcode {
namespace proto {
}  // namespace proto
}  // namespace errorcode
}  // namespace nearby
}  // namespace location
namespace location {
namespace nearby {
namespace errorcode {
namespace proto {
bool ErrorType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ErrorType_strings[6] = {};

static const char ErrorType_names[] =
  "DEVELOPING"
  "DEVICE"
  "NETWORK"
  "OTHERS"
  "SYSTEM"
  "UNKNOWN_TYPE";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ErrorType_entries[] = {
  { {ErrorType_names + 0, 10}, 1 },
  { {ErrorType_names + 10, 6}, 2 },
  { {ErrorType_names + 16, 7}, 4 },
  { {ErrorType_names + 23, 6}, 5 },
  { {ErrorType_names + 29, 6}, 3 },
  { {ErrorType_names + 35, 12}, 0 },
};

static const int ErrorType_entries_by_number[] = {
  5, // 0 -> UNKNOWN_TYPE
  0, // 1 -> DEVELOPING
  1, // 2 -> DEVICE
  4, // 3 -> SYSTEM
  2, // 4 -> NETWORK
  3, // 5 -> OTHERS
};

const std::string& ErrorType_Name(
    ErrorType value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          ErrorType_entries,
          ErrorType_entries_by_number,
          6, ErrorType_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      ErrorType_entries,
      ErrorType_entries_by_number,
      6, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     ErrorType_strings[idx].get();
}
bool ErrorType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ErrorType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      ErrorType_entries, 6, name, &int_value);
  if (success) {
    *value = static_cast<ErrorType>(int_value);
  }
  return success;
}
bool Event_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
    case 12:
    case 13:
    case 14:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> Event_strings[15] = {};

static const char Event_names[] =
  "ACCEPT_CONNECTION"
  "CANCEL_PAYLOAD"
  "CONNECT"
  "DISCONNECT"
  "RECEIVE_PAYLOAD"
  "REJECT_CONNECTION"
  "SEND_PAYLOAD"
  "START_ADVERTISING"
  "START_DISCOVERING"
  "START_LISTENING_INCOMING_CONNECTION"
  "STOP_ADVERTISING"
  "STOP_DISCOVERING"
  "STOP_LISTENING_INCOMING_CONNECTION"
  "UNKNOWN_EVENT"
  "UPGRADE";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry Event_entries[] = {
  { {Event_names + 0, 17}, 9 },
  { {Event_names + 17, 14}, 12 },
  { {Event_names + 31, 7}, 7 },
  { {Event_names + 38, 10}, 8 },
  { {Event_names + 48, 15}, 13 },
  { {Event_names + 63, 17}, 10 },
  { {Event_names + 80, 12}, 11 },
  { {Event_names + 92, 17}, 1 },
  { {Event_names + 109, 17}, 5 },
  { {Event_names + 126, 35}, 3 },
  { {Event_names + 161, 16}, 2 },
  { {Event_names + 177, 16}, 6 },
  { {Event_names + 193, 34}, 4 },
  { {Event_names + 227, 13}, 0 },
  { {Event_names + 240, 7}, 14 },
};

static const int Event_entries_by_number[] = {
  13, // 0 -> UNKNOWN_EVENT
  7, // 1 -> START_ADVERTISING
  10, // 2 -> STOP_ADVERTISING
  9, // 3 -> START_LISTENING_INCOMING_CONNECTION
  12, // 4 -> STOP_LISTENING_INCOMING_CONNECTION
  8, // 5 -> START_DISCOVERING
  11, // 6 -> STOP_DISCOVERING
  2, // 7 -> CONNECT
  3, // 8 -> DISCONNECT
  0, // 9 -> ACCEPT_CONNECTION
  5, // 10 -> REJECT_CONNECTION
  6, // 11 -> SEND_PAYLOAD
  1, // 12 -> CANCEL_PAYLOAD
  4, // 13 -> RECEIVE_PAYLOAD
  14, // 14 -> UPGRADE
};

const std::string& Event_Name(
    Event value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          Event_entries,
          Event_entries_by_number,
          15, Event_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      Event_entries,
      Event_entries_by_number,
      15, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     Event_strings[idx].get();
}
bool Event_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Event* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      Event_entries, 15, name, &int_value);
  if (success) {
    *value = static_cast<Event>(int_value);
  }
  return success;
}
bool CommonError_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> CommonError_strings[7] = {};

static const char CommonError_names[] =
  "FLOW_CANCELED"
  "INVALID_PARAMETER"
  "MEDIUM_NOT_AVAILABLE"
  "OUT_OF_RESOURCE"
  "UNEXPECTED_CALL"
  "UNEXPECTED_MEDIUM_STATE"
  "UNKNOWN_ERROR";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry CommonError_entries[] = {
  { {CommonError_names + 0, 13}, 5 },
  { {CommonError_names + 13, 17}, 1 },
  { {CommonError_names + 30, 20}, 2 },
  { {CommonError_names + 50, 15}, 4 },
  { {CommonError_names + 65, 15}, 6 },
  { {CommonError_names + 80, 23}, 3 },
  { {CommonError_names + 103, 13}, 0 },
};

static const int CommonError_entries_by_number[] = {
  6, // 0 -> UNKNOWN_ERROR
  1, // 1 -> INVALID_PARAMETER
  2, // 2 -> MEDIUM_NOT_AVAILABLE
  5, // 3 -> UNEXPECTED_MEDIUM_STATE
  3, // 4 -> OUT_OF_RESOURCE
  0, // 5 -> FLOW_CANCELED
  4, // 6 -> UNEXPECTED_CALL
};

const std::string& CommonError_Name(
    CommonError value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          CommonError_entries,
          CommonError_entries_by_number,
          7, CommonError_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      CommonError_entries,
      CommonError_entries_by_number,
      7, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     CommonError_strings[idx].get();
}
bool CommonError_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CommonError* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      CommonError_entries, 7, name, &int_value);
  if (success) {
    *value = static_cast<CommonError>(int_value);
  }
  return success;
}
bool StartAdvertisingError_IsValid(int value) {
  switch (value) {
    case 31:
    case 32:
    case 33:
    case 34:
    case 35:
    case 36:
    case 38:
    case 40:
    case 41:
    case 42:
    case 43:
    case 44:
    case 45:
    case 46:
    case 47:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> StartAdvertisingError_strings[15] = {};

static const char StartAdvertisingError_names[] =
  "ACQUIRE_WIFI_AWARE_SESSION_FAILED"
  "AWARE_UPDATE_PUBLISHING_FAILED"
  "BLE_MAX_GATT_ADVERTISEMENT_SLOT_REACHED"
  "BLUETOOTH_ALREADY_ADVERTISED"
  "DUPLICATE_ADVERTISING_REQUESTED"
  "FAST_ADVERTISEMENT_ALREADY_ADVERTISED"
  "MODIFY_BLUETOOTH_NAME_FAILED"
  "MULTIPLE_FAST_ADVERTISEMENT_NOT_ALLOWED"
  "PERSIST_ORIGINAL_BLUETOOTH_NAME_FAILED"
  "SHOULD_ACCEPT_CONNECTIONS_BEFORE_ADVERTISING_ON_WIFI_LAN"
  "START_ADVERTISING_FAILED"
  "START_EXTENDED_ADVERTISING_FAILED"
  "START_GATT_SERVER_FAILED"
  "START_LEGACY_ADVERTISING_FAILED"
  "UNKNOWN_START_ADVERTISING_ERROR";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry StartAdvertisingError_entries[] = {
  { {StartAdvertisingError_names + 0, 33}, 45 },
  { {StartAdvertisingError_names + 33, 30}, 47 },
  { {StartAdvertisingError_names + 63, 39}, 35 },
  { {StartAdvertisingError_names + 102, 28}, 40 },
  { {StartAdvertisingError_names + 130, 31}, 33 },
  { {StartAdvertisingError_names + 161, 37}, 32 },
  { {StartAdvertisingError_names + 198, 28}, 41 },
  { {StartAdvertisingError_names + 226, 39}, 31 },
  { {StartAdvertisingError_names + 265, 38}, 42 },
  { {StartAdvertisingError_names + 303, 56}, 44 },
  { {StartAdvertisingError_names + 359, 24}, 43 },
  { {StartAdvertisingError_names + 383, 33}, 38 },
  { {StartAdvertisingError_names + 416, 24}, 34 },
  { {StartAdvertisingError_names + 440, 31}, 36 },
  { {StartAdvertisingError_names + 471, 31}, 46 },
};

static const int StartAdvertisingError_entries_by_number[] = {
  7, // 31 -> MULTIPLE_FAST_ADVERTISEMENT_NOT_ALLOWED
  5, // 32 -> FAST_ADVERTISEMENT_ALREADY_ADVERTISED
  4, // 33 -> DUPLICATE_ADVERTISING_REQUESTED
  12, // 34 -> START_GATT_SERVER_FAILED
  2, // 35 -> BLE_MAX_GATT_ADVERTISEMENT_SLOT_REACHED
  13, // 36 -> START_LEGACY_ADVERTISING_FAILED
  11, // 38 -> START_EXTENDED_ADVERTISING_FAILED
  3, // 40 -> BLUETOOTH_ALREADY_ADVERTISED
  6, // 41 -> MODIFY_BLUETOOTH_NAME_FAILED
  8, // 42 -> PERSIST_ORIGINAL_BLUETOOTH_NAME_FAILED
  10, // 43 -> START_ADVERTISING_FAILED
  9, // 44 -> SHOULD_ACCEPT_CONNECTIONS_BEFORE_ADVERTISING_ON_WIFI_LAN
  0, // 45 -> ACQUIRE_WIFI_AWARE_SESSION_FAILED
  14, // 46 -> UNKNOWN_START_ADVERTISING_ERROR
  1, // 47 -> AWARE_UPDATE_PUBLISHING_FAILED
};

const std::string& StartAdvertisingError_Name(
    StartAdvertisingError value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          StartAdvertisingError_entries,
          StartAdvertisingError_entries_by_number,
          15, StartAdvertisingError_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      StartAdvertisingError_entries,
      StartAdvertisingError_entries_by_number,
      15, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     StartAdvertisingError_strings[idx].get();
}
bool StartAdvertisingError_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StartAdvertisingError* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      StartAdvertisingError_entries, 15, name, &int_value);
  if (success) {
    *value = static_cast<StartAdvertisingError>(int_value);
  }
  return success;
}
bool StopAdvertisingError_IsValid(int value) {
  switch (value) {
    case 31:
    case 32:
    case 33:
    case 34:
    case 35:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> StopAdvertisingError_strings[5] = {};

static const char StopAdvertisingError_names[] =
  "RESTORE_BLUETOOTH_NAME_FAILED"
  "STOP_ADVERTISING_FAILED"
  "STOP_EXTENDED_ADVERTISING_FAILED"
  "STOP_LEGACY_ADVERTISING_FAILED"
  "UNKNOWN_STOP_ADVERTISING_ERROR";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry StopAdvertisingError_entries[] = {
  { {StopAdvertisingError_names + 0, 29}, 32 },
  { {StopAdvertisingError_names + 29, 23}, 31 },
  { {StopAdvertisingError_names + 52, 32}, 34 },
  { {StopAdvertisingError_names + 84, 30}, 33 },
  { {StopAdvertisingError_names + 114, 30}, 35 },
};

static const int StopAdvertisingError_entries_by_number[] = {
  1, // 31 -> STOP_ADVERTISING_FAILED
  0, // 32 -> RESTORE_BLUETOOTH_NAME_FAILED
  3, // 33 -> STOP_LEGACY_ADVERTISING_FAILED
  2, // 34 -> STOP_EXTENDED_ADVERTISING_FAILED
  4, // 35 -> UNKNOWN_STOP_ADVERTISING_ERROR
};

const std::string& StopAdvertisingError_Name(
    StopAdvertisingError value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          StopAdvertisingError_entries,
          StopAdvertisingError_entries_by_number,
          5, StopAdvertisingError_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      StopAdvertisingError_entries,
      StopAdvertisingError_entries_by_number,
      5, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     StopAdvertisingError_strings[idx].get();
}
bool StopAdvertisingError_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StopAdvertisingError* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      StopAdvertisingError_entries, 5, name, &int_value);
  if (success) {
    *value = static_cast<StopAdvertisingError>(int_value);
  }
  return success;
}
bool StartDiscoveringError_IsValid(int value) {
  switch (value) {
    case 31:
    case 32:
    case 33:
    case 34:
    case 35:
    case 36:
    case 37:
    case 38:
    case 39:
    case 40:
    case 41:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> StartDiscoveringError_strings[11] = {};

static const char StartDiscoveringError_names[] =
  "ACQUIRE_WIFI_AWARE_SESSION_FOR_DISCOVERING_FAILED"
  "DUPLICATE_DISCOVERING_REQUESTED"
  "FETCH_ADVERTISEMENT_FAILED"
  "GATT_FETCH_ADVERTISEMENT_FAILED"
  "INVALID_TARGET_INFO"
  "L2CAP_FETCH_ADVERTISEMENT_FAILED"
  "NOT_AVAILABLE_TO_FETCH_ADVERTISEMENT"
  "START_DISCOVERING_FAILED"
  "START_EXTENDED_DISCOVERING_FAILED"
  "START_LEGACY_DISCOVERING_FAILED"
  "UNKNOWN_START_DISCOVERING_ERROR";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry StartDiscoveringError_entries[] = {
  { {StartDiscoveringError_names + 0, 49}, 40 },
  { {StartDiscoveringError_names + 49, 31}, 31 },
  { {StartDiscoveringError_names + 80, 26}, 36 },
  { {StartDiscoveringError_names + 106, 31}, 37 },
  { {StartDiscoveringError_names + 137, 19}, 35 },
  { {StartDiscoveringError_names + 156, 32}, 38 },
  { {StartDiscoveringError_names + 188, 36}, 39 },
  { {StartDiscoveringError_names + 224, 24}, 34 },
  { {StartDiscoveringError_names + 248, 33}, 33 },
  { {StartDiscoveringError_names + 281, 31}, 32 },
  { {StartDiscoveringError_names + 312, 31}, 41 },
};

static const int StartDiscoveringError_entries_by_number[] = {
  1, // 31 -> DUPLICATE_DISCOVERING_REQUESTED
  9, // 32 -> START_LEGACY_DISCOVERING_FAILED
  8, // 33 -> START_EXTENDED_DISCOVERING_FAILED
  7, // 34 -> START_DISCOVERING_FAILED
  4, // 35 -> INVALID_TARGET_INFO
  2, // 36 -> FETCH_ADVERTISEMENT_FAILED
  3, // 37 -> GATT_FETCH_ADVERTISEMENT_FAILED
  5, // 38 -> L2CAP_FETCH_ADVERTISEMENT_FAILED
  6, // 39 -> NOT_AVAILABLE_TO_FETCH_ADVERTISEMENT
  0, // 40 -> ACQUIRE_WIFI_AWARE_SESSION_FOR_DISCOVERING_FAILED
  10, // 41 -> UNKNOWN_START_DISCOVERING_ERROR
};

const std::string& StartDiscoveringError_Name(
    StartDiscoveringError value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          StartDiscoveringError_entries,
          StartDiscoveringError_entries_by_number,
          11, StartDiscoveringError_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      StartDiscoveringError_entries,
      StartDiscoveringError_entries_by_number,
      11, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     StartDiscoveringError_strings[idx].get();
}
bool StartDiscoveringError_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StartDiscoveringError* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      StartDiscoveringError_entries, 11, name, &int_value);
  if (success) {
    *value = static_cast<StartDiscoveringError>(int_value);
  }
  return success;
}
bool StopDiscoveringError_IsValid(int value) {
  switch (value) {
    case 31:
    case 32:
    case 33:
    case 34:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> StopDiscoveringError_strings[4] = {};

static const char StopDiscoveringError_names[] =
  "STOP_DISCOVERING_FAILED"
  "STOP_EXTENDED_DISCOVERING_FAILED"
  "STOP_LEGACY_DISCOVERING_FAILED"
  "UNKNOWN_STOP_DISCOVERING_ERROR";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry StopDiscoveringError_entries[] = {
  { {StopDiscoveringError_names + 0, 23}, 31 },
  { {StopDiscoveringError_names + 23, 32}, 33 },
  { {StopDiscoveringError_names + 55, 30}, 32 },
  { {StopDiscoveringError_names + 85, 30}, 34 },
};

static const int StopDiscoveringError_entries_by_number[] = {
  0, // 31 -> STOP_DISCOVERING_FAILED
  2, // 32 -> STOP_LEGACY_DISCOVERING_FAILED
  1, // 33 -> STOP_EXTENDED_DISCOVERING_FAILED
  3, // 34 -> UNKNOWN_STOP_DISCOVERING_ERROR
};

const std::string& StopDiscoveringError_Name(
    StopDiscoveringError value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          StopDiscoveringError_entries,
          StopDiscoveringError_entries_by_number,
          4, StopDiscoveringError_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      StopDiscoveringError_entries,
      StopDiscoveringError_entries_by_number,
      4, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     StopDiscoveringError_strings[idx].get();
}
bool StopDiscoveringError_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StopDiscoveringError* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      StopDiscoveringError_entries, 4, name, &int_value);
  if (success) {
    *value = static_cast<StopDiscoveringError>(int_value);
  }
  return success;
}
bool StartListeningIncomingConnectionError_IsValid(int value) {
  switch (value) {
    case 31:
    case 32:
    case 33:
    case 34:
    case 35:
    case 36:
    case 37:
    case 38:
    case 39:
    case 40:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> StartListeningIncomingConnectionError_strings[10] = {};

static const char StartListeningIncomingConnectionError_names[] =
  "ACCEPT_CONNECTION_FAILED"
  "ACCEPT_GATT_CONNECTION_FAILED"
  "ACCEPT_L2CAP_CONNECTION_FAILED"
  "ACCEPT_RECEIVE_AWARE_L2_MESSAGE_FAILED"
  "ACCEPT_SEND_AWARE_L2_MESSAGE_FAILED"
  "CREATE_GATT_SERVER_SOCKET_NOT_READY"
  "CREATE_SERVER_SOCKET_FAILED"
  "DUPLICATE_ACCEPTING_CONNECTION_REQUESTED"
  "OPEN_GATT_SERVER_FAILED"
  "UNKNOWN_START_LISTENING_INCOMING_CONNECTION_ERROR";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry StartListeningIncomingConnectionError_entries[] = {
  { {StartListeningIncomingConnectionError_names + 0, 24}, 36 },
  { {StartListeningIncomingConnectionError_names + 24, 29}, 33 },
  { {StartListeningIncomingConnectionError_names + 53, 30}, 34 },
  { {StartListeningIncomingConnectionError_names + 83, 38}, 40 },
  { {StartListeningIncomingConnectionError_names + 121, 35}, 39 },
  { {StartListeningIncomingConnectionError_names + 156, 35}, 35 },
  { {StartListeningIncomingConnectionError_names + 191, 27}, 37 },
  { {StartListeningIncomingConnectionError_names + 218, 40}, 31 },
  { {StartListeningIncomingConnectionError_names + 258, 23}, 32 },
  { {StartListeningIncomingConnectionError_names + 281, 49}, 38 },
};

static const int StartListeningIncomingConnectionError_entries_by_number[] = {
  7, // 31 -> DUPLICATE_ACCEPTING_CONNECTION_REQUESTED
  8, // 32 -> OPEN_GATT_SERVER_FAILED
  1, // 33 -> ACCEPT_GATT_CONNECTION_FAILED
  2, // 34 -> ACCEPT_L2CAP_CONNECTION_FAILED
  5, // 35 -> CREATE_GATT_SERVER_SOCKET_NOT_READY
  0, // 36 -> ACCEPT_CONNECTION_FAILED
  6, // 37 -> CREATE_SERVER_SOCKET_FAILED
  9, // 38 -> UNKNOWN_START_LISTENING_INCOMING_CONNECTION_ERROR
  4, // 39 -> ACCEPT_SEND_AWARE_L2_MESSAGE_FAILED
  3, // 40 -> ACCEPT_RECEIVE_AWARE_L2_MESSAGE_FAILED
};

const std::string& StartListeningIncomingConnectionError_Name(
    StartListeningIncomingConnectionError value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          StartListeningIncomingConnectionError_entries,
          StartListeningIncomingConnectionError_entries_by_number,
          10, StartListeningIncomingConnectionError_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      StartListeningIncomingConnectionError_entries,
      StartListeningIncomingConnectionError_entries_by_number,
      10, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     StartListeningIncomingConnectionError_strings[idx].get();
}
bool StartListeningIncomingConnectionError_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StartListeningIncomingConnectionError* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      StartListeningIncomingConnectionError_entries, 10, name, &int_value);
  if (success) {
    *value = static_cast<StartListeningIncomingConnectionError>(int_value);
  }
  return success;
}
bool StopListeningIncomingConnectionError_IsValid(int value) {
  switch (value) {
    case 31:
    case 32:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> StopListeningIncomingConnectionError_strings[2] = {};

static const char StopListeningIncomingConnectionError_names[] =
  "STOP_ACCEPTING_CONNECTION_FAILED"
  "UNKNOWN_STOP_LISTENING_INCOMING_CONNECTION_ERROR";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry StopListeningIncomingConnectionError_entries[] = {
  { {StopListeningIncomingConnectionError_names + 0, 32}, 31 },
  { {StopListeningIncomingConnectionError_names + 32, 48}, 32 },
};

static const int StopListeningIncomingConnectionError_entries_by_number[] = {
  0, // 31 -> STOP_ACCEPTING_CONNECTION_FAILED
  1, // 32 -> UNKNOWN_STOP_LISTENING_INCOMING_CONNECTION_ERROR
};

const std::string& StopListeningIncomingConnectionError_Name(
    StopListeningIncomingConnectionError value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          StopListeningIncomingConnectionError_entries,
          StopListeningIncomingConnectionError_entries_by_number,
          2, StopListeningIncomingConnectionError_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      StopListeningIncomingConnectionError_entries,
      StopListeningIncomingConnectionError_entries_by_number,
      2, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     StopListeningIncomingConnectionError_strings[idx].get();
}
bool StopListeningIncomingConnectionError_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StopListeningIncomingConnectionError* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      StopListeningIncomingConnectionError_entries, 2, name, &int_value);
  if (success) {
    *value = static_cast<StopListeningIncomingConnectionError>(int_value);
  }
  return success;
}
bool ConnectError_IsValid(int value) {
  switch (value) {
    case 31:
    case 32:
    case 33:
    case 34:
    case 35:
    case 36:
    case 37:
    case 38:
    case 39:
    case 40:
    case 41:
    case 42:
    case 43:
    case 44:
    case 45:
    case 46:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ConnectError_strings[16] = {};

static const char ConnectError_names[] =
  "CONNECTION_LOST"
  "CONNECT_READ_AWARE_L2_MESSAGE_FAILED"
  "CONNECT_SEND_AWARE_L2_MESSAGE_FAILED"
  "CONNECT_TO_NETWORK_FAILED"
  "DUPLICATE_CONNECTION_REQUESTED"
  "ESTABLISH_CONNECTION_FAILED"
  "ESTABLISH_GATT_CONNECTION_FAILED"
  "ESTABLISH_L2CAP_CONNECTION_FAILED"
  "GATT_SWITCH_TO_DATA_TRANSFERRING_FAILED"
  "INVALID_MAC_ADDRESS"
  "L2CAP_SWITCH_TO_DATA_TRANSFERRING_FAILED"
  "REQUEST_GATT_CONNECTION_PRIORITY_FAILED"
  "SLEEP_AFTER_GATT_CONNECTED_INTERRUPTED"
  "SLEEP_BEFORE_CONNECT_GATT_INTERRUPTED"
  "UNEXPECT_TARGET_LOST"
  "UNKNOWN_CONNECT_ERROR";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ConnectError_entries[] = {
  { {ConnectError_names + 0, 15}, 42 },
  { {ConnectError_names + 15, 36}, 46 },
  { {ConnectError_names + 51, 36}, 45 },
  { {ConnectError_names + 87, 25}, 43 },
  { {ConnectError_names + 112, 30}, 41 },
  { {ConnectError_names + 142, 27}, 40 },
  { {ConnectError_names + 169, 32}, 32 },
  { {ConnectError_names + 201, 33}, 33 },
  { {ConnectError_names + 234, 39}, 39 },
  { {ConnectError_names + 273, 19}, 34 },
  { {ConnectError_names + 292, 40}, 38 },
  { {ConnectError_names + 332, 39}, 37 },
  { {ConnectError_names + 371, 38}, 36 },
  { {ConnectError_names + 409, 37}, 35 },
  { {ConnectError_names + 446, 20}, 31 },
  { {ConnectError_names + 466, 21}, 44 },
};

static const int ConnectError_entries_by_number[] = {
  14, // 31 -> UNEXPECT_TARGET_LOST
  6, // 32 -> ESTABLISH_GATT_CONNECTION_FAILED
  7, // 33 -> ESTABLISH_L2CAP_CONNECTION_FAILED
  9, // 34 -> INVALID_MAC_ADDRESS
  13, // 35 -> SLEEP_BEFORE_CONNECT_GATT_INTERRUPTED
  12, // 36 -> SLEEP_AFTER_GATT_CONNECTED_INTERRUPTED
  11, // 37 -> REQUEST_GATT_CONNECTION_PRIORITY_FAILED
  10, // 38 -> L2CAP_SWITCH_TO_DATA_TRANSFERRING_FAILED
  8, // 39 -> GATT_SWITCH_TO_DATA_TRANSFERRING_FAILED
  5, // 40 -> ESTABLISH_CONNECTION_FAILED
  4, // 41 -> DUPLICATE_CONNECTION_REQUESTED
  0, // 42 -> CONNECTION_LOST
  3, // 43 -> CONNECT_TO_NETWORK_FAILED
  15, // 44 -> UNKNOWN_CONNECT_ERROR
  2, // 45 -> CONNECT_SEND_AWARE_L2_MESSAGE_FAILED
  1, // 46 -> CONNECT_READ_AWARE_L2_MESSAGE_FAILED
};

const std::string& ConnectError_Name(
    ConnectError value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          ConnectError_entries,
          ConnectError_entries_by_number,
          16, ConnectError_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      ConnectError_entries,
      ConnectError_entries_by_number,
      16, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     ConnectError_strings[idx].get();
}
bool ConnectError_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConnectError* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      ConnectError_entries, 16, name, &int_value);
  if (success) {
    *value = static_cast<ConnectError>(int_value);
  }
  return success;
}
bool DisconnectError_IsValid(int value) {
  switch (value) {
    case 31:
    case 32:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> DisconnectError_strings[2] = {};

static const char DisconnectError_names[] =
  "DISCONNECT_NETWORK_FAILED"
  "UNKNOWN_DISCONNECT_ERROR";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry DisconnectError_entries[] = {
  { {DisconnectError_names + 0, 25}, 31 },
  { {DisconnectError_names + 25, 24}, 32 },
};

static const int DisconnectError_entries_by_number[] = {
  0, // 31 -> DISCONNECT_NETWORK_FAILED
  1, // 32 -> UNKNOWN_DISCONNECT_ERROR
};

const std::string& DisconnectError_Name(
    DisconnectError value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          DisconnectError_entries,
          DisconnectError_entries_by_number,
          2, DisconnectError_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      DisconnectError_entries,
      DisconnectError_entries_by_number,
      2, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     DisconnectError_strings[idx].get();
}
bool DisconnectError_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DisconnectError* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      DisconnectError_entries, 2, name, &int_value);
  if (success) {
    *value = static_cast<DisconnectError>(int_value);
  }
  return success;
}
bool SendPayloadError_IsValid(int value) {
  switch (value) {
    case 31:
    case 32:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> SendPayloadError_strings[2] = {};

static const char SendPayloadError_names[] =
  "SEND_PAYLOAD_FAILED"
  "UNKNOWN_SEND_PAYLOAD_ERROR";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry SendPayloadError_entries[] = {
  { {SendPayloadError_names + 0, 19}, 32 },
  { {SendPayloadError_names + 19, 26}, 31 },
};

static const int SendPayloadError_entries_by_number[] = {
  1, // 31 -> UNKNOWN_SEND_PAYLOAD_ERROR
  0, // 32 -> SEND_PAYLOAD_FAILED
};

const std::string& SendPayloadError_Name(
    SendPayloadError value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          SendPayloadError_entries,
          SendPayloadError_entries_by_number,
          2, SendPayloadError_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      SendPayloadError_entries,
      SendPayloadError_entries_by_number,
      2, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     SendPayloadError_strings[idx].get();
}
bool SendPayloadError_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SendPayloadError* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      SendPayloadError_entries, 2, name, &int_value);
  if (success) {
    *value = static_cast<SendPayloadError>(int_value);
  }
  return success;
}
bool ReceivePayloadError_IsValid(int value) {
  switch (value) {
    case 31:
    case 32:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ReceivePayloadError_strings[2] = {};

static const char ReceivePayloadError_names[] =
  "RECEIVE_PAYLOAD_FAILED"
  "UNKNOWN_RECEIVE_PAYLOAD_ERROR";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ReceivePayloadError_entries[] = {
  { {ReceivePayloadError_names + 0, 22}, 32 },
  { {ReceivePayloadError_names + 22, 29}, 31 },
};

static const int ReceivePayloadError_entries_by_number[] = {
  1, // 31 -> UNKNOWN_RECEIVE_PAYLOAD_ERROR
  0, // 32 -> RECEIVE_PAYLOAD_FAILED
};

const std::string& ReceivePayloadError_Name(
    ReceivePayloadError value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          ReceivePayloadError_entries,
          ReceivePayloadError_entries_by_number,
          2, ReceivePayloadError_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      ReceivePayloadError_entries,
      ReceivePayloadError_entries_by_number,
      2, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     ReceivePayloadError_strings[idx].get();
}
bool ReceivePayloadError_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ReceivePayloadError* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      ReceivePayloadError_entries, 2, name, &int_value);
  if (success) {
    *value = static_cast<ReceivePayloadError>(int_value);
  }
  return success;
}
bool UpgradeError_IsValid(int value) {
  switch (value) {
    case 31:
    case 32:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> UpgradeError_strings[2] = {};

static const char UpgradeError_names[] =
  "CREATE_P2P_GROUP_FAILED"
  "UNKNOWN_UPGRADE_ERROR";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry UpgradeError_entries[] = {
  { {UpgradeError_names + 0, 23}, 32 },
  { {UpgradeError_names + 23, 21}, 31 },
};

static const int UpgradeError_entries_by_number[] = {
  1, // 31 -> UNKNOWN_UPGRADE_ERROR
  0, // 32 -> CREATE_P2P_GROUP_FAILED
};

const std::string& UpgradeError_Name(
    UpgradeError value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          UpgradeError_entries,
          UpgradeError_entries_by_number,
          2, UpgradeError_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      UpgradeError_entries,
      UpgradeError_entries_by_number,
      2, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     UpgradeError_strings[idx].get();
}
bool UpgradeError_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, UpgradeError* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      UpgradeError_entries, 2, name, &int_value);
  if (success) {
    *value = static_cast<UpgradeError>(int_value);
  }
  return success;
}
bool AcceptConnectionError_IsValid(int value) {
  switch (value) {
    case 31:
    case 32:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> AcceptConnectionError_strings[2] = {};

static const char AcceptConnectionError_names[] =
  "RESPOND_ACCEPT_CONNECTION_FAILED"
  "UNKNOWN_ACCEPT_CONNECTION_ERROR";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry AcceptConnectionError_entries[] = {
  { {AcceptConnectionError_names + 0, 32}, 32 },
  { {AcceptConnectionError_names + 32, 31}, 31 },
};

static const int AcceptConnectionError_entries_by_number[] = {
  1, // 31 -> UNKNOWN_ACCEPT_CONNECTION_ERROR
  0, // 32 -> RESPOND_ACCEPT_CONNECTION_FAILED
};

const std::string& AcceptConnectionError_Name(
    AcceptConnectionError value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          AcceptConnectionError_entries,
          AcceptConnectionError_entries_by_number,
          2, AcceptConnectionError_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      AcceptConnectionError_entries,
      AcceptConnectionError_entries_by_number,
      2, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     AcceptConnectionError_strings[idx].get();
}
bool AcceptConnectionError_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AcceptConnectionError* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      AcceptConnectionError_entries, 2, name, &int_value);
  if (success) {
    *value = static_cast<AcceptConnectionError>(int_value);
  }
  return success;
}
bool RejectConnectionError_IsValid(int value) {
  switch (value) {
    case 31:
    case 32:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> RejectConnectionError_strings[2] = {};

static const char RejectConnectionError_names[] =
  "RESPOND_REJECT_CONNECTION_FAILED"
  "UNKNOWN_REJECT_CONNECTION_ERROR";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry RejectConnectionError_entries[] = {
  { {RejectConnectionError_names + 0, 32}, 32 },
  { {RejectConnectionError_names + 32, 31}, 31 },
};

static const int RejectConnectionError_entries_by_number[] = {
  1, // 31 -> UNKNOWN_REJECT_CONNECTION_ERROR
  0, // 32 -> RESPOND_REJECT_CONNECTION_FAILED
};

const std::string& RejectConnectionError_Name(
    RejectConnectionError value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          RejectConnectionError_entries,
          RejectConnectionError_entries_by_number,
          2, RejectConnectionError_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      RejectConnectionError_entries,
      RejectConnectionError_entries_by_number,
      2, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     RejectConnectionError_strings[idx].get();
}
bool RejectConnectionError_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, RejectConnectionError* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      RejectConnectionError_entries, 2, name, &int_value);
  if (success) {
    *value = static_cast<RejectConnectionError>(int_value);
  }
  return success;
}
bool Description_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
    case 12:
    case 13:
    case 14:
    case 15:
    case 16:
    case 17:
    case 18:
    case 19:
    case 20:
    case 21:
    case 22:
    case 23:
    case 24:
    case 25:
    case 26:
    case 27:
    case 30:
    case 31:
    case 32:
    case 33:
    case 34:
    case 35:
    case 36:
    case 37:
    case 38:
    case 39:
    case 40:
    case 41:
    case 42:
    case 43:
    case 44:
    case 45:
    case 46:
    case 47:
    case 48:
    case 49:
    case 50:
    case 51:
    case 52:
    case 53:
    case 54:
    case 55:
    case 56:
    case 57:
    case 58:
    case 59:
    case 60:
    case 61:
    case 62:
    case 63:
    case 64:
    case 65:
    case 66:
    case 67:
    case 68:
    case 69:
    case 70:
    case 71:
    case 72:
    case 73:
    case 74:
    case 75:
    case 76:
    case 77:
    case 78:
    case 79:
    case 80:
    case 81:
    case 82:
    case 83:
    case 84:
    case 85:
    case 86:
    case 87:
    case 88:
    case 89:
    case 90:
    case 91:
    case 92:
    case 93:
    case 94:
    case 95:
    case 96:
    case 97:
    case 98:
    case 99:
    case 100:
    case 101:
    case 102:
    case 103:
    case 104:
    case 105:
    case 106:
    case 107:
    case 108:
    case 109:
    case 110:
    case 111:
    case 112:
    case 113:
    case 114:
    case 115:
    case 116:
    case 117:
    case 118:
    case 119:
    case 120:
    case 121:
    case 122:
    case 123:
    case 124:
    case 125:
    case 126:
    case 127:
    case 128:
    case 129:
    case 130:
    case 131:
    case 132:
    case 133:
    case 134:
    case 135:
    case 136:
    case 137:
    case 138:
    case 139:
    case 140:
    case 141:
    case 142:
    case 143:
    case 144:
    case 145:
    case 146:
    case 147:
    case 148:
    case 149:
    case 150:
    case 151:
    case 152:
    case 153:
    case 154:
    case 155:
    case 156:
    case 157:
    case 158:
    case 159:
    case 160:
    case 161:
    case 162:
    case 163:
    case 164:
    case 165:
    case 166:
    case 167:
    case 168:
    case 169:
    case 170:
    case 171:
    case 172:
    case 173:
    case 174:
    case 175:
    case 176:
    case 177:
    case 178:
    case 179:
    case 180:
    case 181:
    case 182:
    case 183:
    case 184:
    case 185:
    case 186:
    case 187:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> Description_strings[186] = {};

static const char Description_names[] =
  "ACQUIRE_P2P_CHANNEL_FAILED"
  "ADD_NETWORK_FAILED"
  "ADVERTISE_FAILED_ALREADY_STARTED"
  "ADVERTISE_FAILED_DATA_TOO_LARGE"
  "ADVERTISE_FAILED_FEATURE_UNSUPPORTED"
  "ADVERTISE_FAILED_INTERNAL_ERROR"
  "ADVERTISE_FAILED_TOO_MANY_ADVERTISERS"
  "ALREADY_HAS_GATT_CONNECTION"
  "ALREADY_IN_PROGRESS"
  "AWARE_DATA_PATH_RAN_OUT"
  "AWARE_L2_MESSAGE_CANCELLATION_RECEIVED"
  "AWARE_L2_MESSAGE_HOST_NETWORK_ERROR"
  "AWARE_L2_MESSAGE_IP_AVAILABLE_ERROR"
  "AWARE_L2_MESSAGE_NETWORK_AVAILABLE_ERROR"
  "AWARE_PUBLISH_SESSION_RAN_OUT"
  "AWARE_SUBSCRIBE_SESSION_RAN_OUT"
  "AWARE_UNAVAILABLE"
  "AWARE_UPDATE_PUBLISHING_CONFIG_FAILED"
  "BIND_NFC_SERVICE_FAILED"
  "BLUETOOTH_SCAN_REJUVENATE_FAILED"
  "BLUETOOTH_SOCKET_CLOSED_AFTER_CONNECTED"
  "BLUETOOTH_SOCKET_NOT_IN_LISTENING_STATE"
  "BROKEN_PIPE"
  "BUSY"
  "CLOSE_SERVER_SOCKET_FAILED"
  "CONNECTIONS_FEATURE_DISABLED"
  "CONNECTION_ABORT"
  "CONNET_TO_SOCKET_CANCELLED"
  "CREATE_OFFER_FAILED"
  "EMPTY_TACHYON_ICE_SERVER"
  "EMPTY_WORK_SOURCE_CACHE"
  "EXECUTION_EXCEPTION"
  "FAIL_TO_RECEIVE_L2CAP_PACKET"
  "FEATURE_BLUETOOTH_LE_NOT_SUPPORTED"
  "FEATURE_BLUETOOTH_NOT_SUPPORTED"
  "FEATURE_NFC_HOST_CARD_EMULATION_NOT_SUPPORTED"
  "FEATURE_NFC_NOT_SUPPORTED"
  "FEATURE_USB_ACCESSORY_NOT_SUPPORTED"
  "FEATURE_USB_HOST_NOT_SUPPORTED"
  "FEATURE_USB_PORTS_NOT_FOUND"
  "FEATURE_WIFI_AWARE_NOT_SUPPORTED"
  "FEATURE_WIFI_DIRECT_NOT_SUPPORTED"
  "FEATURE_WIFI_NOT_SUPPORTED"
  "GET_ADDRESS_FAILED"
  "HOSTED_NETWORK_UNAVAILABLE"
  "HOTSPOT_NOT_STARTED"
  "INTERNAL_ERROR"
  "INTERRUPTED_EXCEPTION"
  "INVALID_ADVERTISEMENT_HEADER_DATA"
  "INVALID_ARGS"
  "INVALID_BLUETOOTH_CHANNEL"
  "INVALID_BLUETOOTH_SOCKET_SIGNAL_SIZE"
  "INVALID_BLUETOOTH_SOCKET_SIGNAL_STATUS"
  "INVALID_BLUETOOTH_SOCKET_STATE_BEFORE_CONNECT"
  "INVALID_FAST_ADVERTISEMENT_DATA"
  "INVALID_FAST_PAIR_MODEL_ID"
  "INVALID_IPV4_ADDRESS"
  "INVALID_IPV6_ADDRESS"
  "INVALID_NETWORK_ID"
  "INVALID_PACKET_BYTES"
  "INVALID_PACKET_LENGTH"
  "INVALID_PORT_NUMBER"
  "INVALID_REGULAR_ADVERTISEMENT_DATA"
  "INVALID_REMOTE_ADDRESS"
  "INVALID_VERSION"
  "INVALID_WEBRTC_STATE"
  "INVOKE_API_FAILED"
  "IN_BLACK_LIST"
  "IS_LOOPBACK_ADDRESS"
  "JOIN_AWARE_NETWORK_CANCELLED"
  "L2CAP_UNAVAILABLE"
  "MULTICAST_NOT_SUPPORTED"
  "MULTIPLEX_SOCKET_DISABLED"
  "MULTIPLEX_SOCKET_EXECUTION_EXCEPTION"
  "MULTIPLEX_SOCKET_INTERRUPTED_EXCEPTION"
  "MULTIPLEX_SOCKET_IOEXCEPTION"
  "MULTIPLEX_SOCKET_NOT_LISTENING"
  "MULTIPLEX_SOCKET_TIMEOUT"
  "MULTIPLEX_SOCKET_UNKNOWN_ERROR"
  "MULTIPLEX_SOCKET_UNKNOWN_RESPONSE_CODE"
  "NETWORK_ALREADY_JOINED"
  "NETWORK_ERROR_EHOSTUNREACH"
  "NETWORK_ERROR_ENETUNREACH"
  "NETWORK_UNAVAILABLE"
  "NFC_CREATE_SOCKET_FAILED"
  "NFC_SERVICE_DIED"
  "NFC_TECH_NOT_SUPPORTED"
  "NOT_AUTHORIZED"
  "NSD_NOT_ENABLED"
  "NULL_ADDRESS"
  "NULL_ADVERTISEMENT_BYTES"
  "NULL_BLE_PERIPHERAL"
  "NULL_BLUETOOTH_ADAPTER"
  "NULL_BLUETOOTH_DEVICE"
  "NULL_BLUETOOTH_DEVICE_NAME"
  "NULL_BLUETOOTH_GATT"
  "NULL_BLUETOOTH_LE_ADVERTISER_COMPAT"
  "NULL_BLUETOOTH_LE_SCANNER_COMPAT"
  "NULL_BLUETOOTH_MANAGER"
  "NULL_BLUETOOTH_PROXY"
  "NULL_CALLBACK"
  "NULL_CONNECTIVITY_MANAGER"
  "NULL_DATA_CHANNEL"
  "NULL_DROID_GUARD_RESULT"
  "NULL_LOCAL_ADDRESS"
  "NULL_MESSAGE"
  "NULL_NFC_TAG"
  "NULL_PASSWORD"
  "NULL_SERVICE_ID"
  "NULL_SERVICE_INFO"
  "NULL_SERVICE_NAME"
  "NULL_SERVICE_TYPE"
  "NULL_SSID"
  "NULL_WIFI_AWARE_MANAGER"
  "NULL_WIFI_AWARE_PEER"
  "NULL_WIFI_MANAGER"
  "NULL_WIFI_P2P_MANAGER"
  "NULL_WORK_SOURCE"
  "P2P_GROUP_FORMED"
  "P2P_UNSUPPORTED"
  "POTENTIAL_SRD_ISSUE"
  "POTENTIAL_WEBRTC_LIB_LOADING_FAILURE"
  "PUBLISH_EMPTY_ADVERTISEMENT_FAILED"
  "READ_CHARACTERISTIC_FAILED"
  "REFLECTION_ERROR"
  "REMOTE_EXCEPTION"
  "SCAN_FAILED_ALREADY_STARTED"
  "SCAN_FAILED_APPLICATION_REGISTRATION_FAILED"
  "SCAN_FAILED_BLUETOOTH_DISABLED"
  "SCAN_FAILED_FEATURE_UNSUPPORTED"
  "SCAN_FAILED_INTERNAL_ERROR"
  "SCAN_FILTERS_NOT_ALLOWED_FOR_LOCATION"
  "SERVER_SOCKET_UNAVAILABLE"
  "SET_CONNECTION_PRIORITY_FAILED"
  "SET_CONNECTION_PRIORITY_INTERRUPTED"
  "SET_SCAN_MODE_FAILED"
  "SOCKET_ALREADY_BOUND"
  "SOCKET_ALREADY_CONNECTED"
  "SOCKET_BIND_LISTEN_FAILED"
  "SOCKET_CLOSED"
  "SOCKET_CLOSED_OR_TIMEOUT"
  "SOCKET_NOT_BOUND"
  "STALE_ANDROID_VERSION"
  "STALE_SDK_VERSION"
  "TACHYON_ALREADY_START_RECEIVE_MESSAGE"
  "TACHYON_GET_ICE_SERVER_AUTH_EXCEPTION"
  "TACHYON_GET_ICE_SERVER_STATUS_EXCEPTION"
  "TACHYON_RECEIVE_MESSAGE_AUTH_EXCEPTION"
  "TACHYON_RECEIVE_MESSAGE_EXECUTION_EXCEPTION"
  "TACHYON_RECEIVE_MESSAGE_FAILED"
  "TACHYON_RECEIVE_MESSAGE_INTERRUPTED"
  "TACHYON_RECEIVE_MESSAGE_STATUS_EXCEPTION"
  "TACHYON_RECEIVE_MESSAGE_TIMEOUT"
  "TACHYON_SEND_MESSAGE_AUTH_EXCEPTION"
  "TACHYON_SEND_MESSAGE_STATUS_EXCEPTION"
  "TACHYON_SIGNALING_MESSENGER_EXIST"
  "TIE_BREAK_LOSER"
  "TIMEOUT"
  "UNEXPECTED_BLUETOOTH_STATE"
  "UNEXPECTED_EOF_EXCEPTION"
  "UNEXPECTED_GATT_DESCRIPTOR"
  "UNEXPECTED_PACKET_CONTENT"
  "UNKNOWN"
  "UNKNOWN_IO_EXCEPTION"
  "UNREGISTER_NSD_MANAGER_FAILED"
  "UNSUPPORTED_DEVICE_TYPE"
  "UNSUPPORTED_DEVICE_TYPE_AUTO"
  "UNSUPPORTED_DEVICE_TYPE_CHROME_OS"
  "UNSUPPORTED_DEVICE_TYPE_PHONE"
  "UNSUPPORTED_DEVICE_TYPE_TABLET"
  "UNSUPPORTED_DEVICE_TYPE_TV"
  "UNSUPPORTED_DEVICE_TYPE_WEAR"
  "UPDATE_NETWORK_FAILED"
  "USER_RESTRICTION_DISALLOWED"
  "WEBRTC_ALREADY_INITIALIZED"
  "WEBRTC_CONNECTION_FLOW_EXIST"
  "WIFI_AWARE_STARTED"
  "WIFI_HOTSPOT_ENABLED"
  "WIFI_MANAGER_ENABLE_NETWORK_FAILED"
  "WIFI_MANAGER_RECONNECT_FAILED"
  "WIFI_SIGNAL_STRENGTH_POOR"
  "WITHOUT_ACTIVE_AWARE_NETWORK"
  "WITHOUT_ACTIVE_NETWORK"
  "WITHOUT_CONNECTED_WIFI_NETWORK"
  "WITHOUT_JOINED_AWARE_NETWORK"
  "WITHOUT_PSM_VALUE";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry Description_entries[] = {
  { {Description_names + 0, 26}, 96 },
  { {Description_names + 26, 18}, 103 },
  { {Description_names + 44, 32}, 14 },
  { {Description_names + 76, 31}, 15 },
  { {Description_names + 107, 36}, 16 },
  { {Description_names + 143, 31}, 17 },
  { {Description_names + 174, 37}, 18 },
  { {Description_names + 211, 27}, 165 },
  { {Description_names + 238, 19}, 105 },
  { {Description_names + 257, 23}, 153 },
  { {Description_names + 280, 38}, 159 },
  { {Description_names + 318, 35}, 156 },
  { {Description_names + 353, 35}, 158 },
  { {Description_names + 388, 40}, 157 },
  { {Description_names + 428, 29}, 151 },
  { {Description_names + 457, 31}, 152 },
  { {Description_names + 488, 17}, 74 },
  { {Description_names + 505, 37}, 163 },
  { {Description_names + 542, 23}, 82 },
  { {Description_names + 565, 32}, 51 },
  { {Description_names + 597, 39}, 57 },
  { {Description_names + 636, 39}, 135 },
  { {Description_names + 675, 11}, 175 },
  { {Description_names + 686, 4}, 99 },
  { {Description_names + 690, 26}, 149 },
  { {Description_names + 716, 28}, 3 },
  { {Description_names + 744, 16}, 176 },
  { {Description_names + 760, 26}, 90 },
  { {Description_names + 786, 19}, 148 },
  { {Description_names + 805, 24}, 126 },
  { {Description_names + 829, 23}, 44 },
  { {Description_names + 852, 19}, 20 },
  { {Description_names + 871, 28}, 129 },
  { {Description_names + 899, 34}, 6 },
  { {Description_names + 933, 31}, 5 },
  { {Description_names + 964, 45}, 27 },
  { {Description_names + 1009, 25}, 26 },
  { {Description_names + 1034, 35}, 178 },
  { {Description_names + 1069, 30}, 177 },
  { {Description_names + 1099, 27}, 179 },
  { {Description_names + 1126, 32}, 36 },
  { {Description_names + 1158, 33}, 93 },
  { {Description_names + 1191, 26}, 76 },
  { {Description_names + 1217, 18}, 138 },
  { {Description_names + 1235, 26}, 162 },
  { {Description_names + 1261, 19}, 144 },
  { {Description_names + 1280, 14}, 98 },
  { {Description_names + 1294, 21}, 19 },
  { {Description_names + 1315, 33}, 11 },
  { {Description_names + 1348, 12}, 106 },
  { {Description_names + 1360, 25}, 58 },
  { {Description_names + 1385, 36}, 136 },
  { {Description_names + 1421, 38}, 137 },
  { {Description_names + 1459, 45}, 56 },
  { {Description_names + 1504, 31}, 10 },
  { {Description_names + 1535, 26}, 9 },
  { {Description_names + 1561, 20}, 65 },
  { {Description_names + 1581, 20}, 66 },
  { {Description_names + 1601, 18}, 108 },
  { {Description_names + 1619, 20}, 62 },
  { {Description_names + 1639, 21}, 61 },
  { {Description_names + 1660, 19}, 32 },
  { {Description_names + 1679, 34}, 12 },
  { {Description_names + 1713, 22}, 142 },
  { {Description_names + 1735, 15}, 68 },
  { {Description_names + 1750, 20}, 146 },
  { {Description_names + 1770, 17}, 23 },
  { {Description_names + 1787, 13}, 75 },
  { {Description_names + 1800, 19}, 140 },
  { {Description_names + 1819, 28}, 86 },
  { {Description_names + 1847, 17}, 164 },
  { {Description_names + 1864, 23}, 30 },
  { {Description_names + 1887, 25}, 182 },
  { {Description_names + 1912, 36}, 186 },
  { {Description_names + 1948, 38}, 187 },
  { {Description_names + 1986, 28}, 184 },
  { {Description_names + 2014, 30}, 181 },
  { {Description_names + 2044, 24}, 183 },
  { {Description_names + 2068, 30}, 180 },
  { {Description_names + 2098, 38}, 185 },
  { {Description_names + 2136, 22}, 85 },
  { {Description_names + 2158, 26}, 101 },
  { {Description_names + 2184, 25}, 102 },
  { {Description_names + 2209, 19}, 87 },
  { {Description_names + 2228, 24}, 83 },
  { {Description_names + 2252, 16}, 81 },
  { {Description_names + 2268, 22}, 80 },
  { {Description_names + 2290, 14}, 107 },
  { {Description_names + 2304, 15}, 31 },
  { {Description_names + 2319, 12}, 67 },
  { {Description_names + 2331, 24}, 2 },
  { {Description_names + 2355, 19}, 52 },
  { {Description_names + 2374, 22}, 8 },
  { {Description_names + 2396, 21}, 59 },
  { {Description_names + 2417, 26}, 21 },
  { {Description_names + 2443, 19}, 53 },
  { {Description_names + 2462, 35}, 13 },
  { {Description_names + 2497, 32}, 43 },
  { {Description_names + 2529, 22}, 7 },
  { {Description_names + 2551, 20}, 60 },
  { {Description_names + 2571, 13}, 42 },
  { {Description_names + 2584, 25}, 37 },
  { {Description_names + 2609, 17}, 147 },
  { {Description_names + 2626, 23}, 113 },
  { {Description_names + 2649, 18}, 139 },
  { {Description_names + 2667, 12}, 171 },
  { {Description_names + 2679, 12}, 25 },
  { {Description_names + 2691, 13}, 92 },
  { {Description_names + 2704, 15}, 1 },
  { {Description_names + 2719, 17}, 40 },
  { {Description_names + 2736, 17}, 33 },
  { {Description_names + 2753, 17}, 34 },
  { {Description_names + 2770, 9}, 91 },
  { {Description_names + 2779, 23}, 38 },
  { {Description_names + 2802, 20}, 84 },
  { {Description_names + 2822, 17}, 77 },
  { {Description_names + 2839, 21}, 94 },
  { {Description_names + 2860, 16}, 41 },
  { {Description_names + 2876, 16}, 95 },
  { {Description_names + 2892, 15}, 97 },
  { {Description_names + 2907, 19}, 155 },
  { {Description_names + 2926, 36}, 127 },
  { {Description_names + 2962, 34}, 134 },
  { {Description_names + 2996, 26}, 72 },
  { {Description_names + 3022, 16}, 100 },
  { {Description_names + 3038, 16}, 55 },
  { {Description_names + 3054, 27}, 45 },
  { {Description_names + 3081, 43}, 46 },
  { {Description_names + 3124, 30}, 49 },
  { {Description_names + 3154, 31}, 48 },
  { {Description_names + 3185, 26}, 47 },
  { {Description_names + 3211, 37}, 50 },
  { {Description_names + 3248, 25}, 161 },
  { {Description_names + 3273, 30}, 69 },
  { {Description_names + 3303, 35}, 70 },
  { {Description_names + 3338, 20}, 22 },
  { {Description_names + 3358, 20}, 143 },
  { {Description_names + 3378, 24}, 79 },
  { {Description_names + 3402, 25}, 131 },
  { {Description_names + 3427, 13}, 78 },
  { {Description_names + 3440, 24}, 64 },
  { {Description_names + 3464, 16}, 141 },
  { {Description_names + 3480, 21}, 39 },
  { {Description_names + 3501, 17}, 4 },
  { {Description_names + 3518, 37}, 115 },
  { {Description_names + 3555, 37}, 124 },
  { {Description_names + 3592, 39}, 125 },
  { {Description_names + 3631, 38}, 120 },
  { {Description_names + 3669, 43}, 118 },
  { {Description_names + 3712, 30}, 116 },
  { {Description_names + 3742, 35}, 117 },
  { {Description_names + 3777, 40}, 121 },
  { {Description_names + 3817, 31}, 119 },
  { {Description_names + 3848, 35}, 122 },
  { {Description_names + 3883, 37}, 123 },
  { {Description_names + 3920, 33}, 114 },
  { {Description_names + 3953, 15}, 160 },
  { {Description_names + 3968, 7}, 24 },
  { {Description_names + 3975, 26}, 54 },
  { {Description_names + 4001, 24}, 63 },
  { {Description_names + 4025, 26}, 128 },
  { {Description_names + 4051, 25}, 132 },
  { {Description_names + 4076, 7}, 0 },
  { {Description_names + 4083, 20}, 71 },
  { {Description_names + 4103, 29}, 133 },
  { {Description_names + 4132, 23}, 166 },
  { {Description_names + 4155, 28}, 168 },
  { {Description_names + 4183, 33}, 167 },
  { {Description_names + 4216, 29}, 173 },
  { {Description_names + 4245, 30}, 174 },
  { {Description_names + 4275, 26}, 169 },
  { {Description_names + 4301, 28}, 170 },
  { {Description_names + 4329, 21}, 104 },
  { {Description_names + 4350, 27}, 172 },
  { {Description_names + 4377, 26}, 145 },
  { {Description_names + 4403, 28}, 112 },
  { {Description_names + 4431, 18}, 150 },
  { {Description_names + 4449, 20}, 73 },
  { {Description_names + 4469, 34}, 109 },
  { {Description_names + 4503, 29}, 110 },
  { {Description_names + 4532, 25}, 154 },
  { {Description_names + 4557, 28}, 88 },
  { {Description_names + 4585, 22}, 111 },
  { {Description_names + 4607, 30}, 35 },
  { {Description_names + 4637, 28}, 89 },
  { {Description_names + 4665, 17}, 130 },
};

static const int Description_entries_by_number[] = {
  162, // 0 -> UNKNOWN
  108, // 1 -> NULL_SERVICE_ID
  90, // 2 -> NULL_ADVERTISEMENT_BYTES
  25, // 3 -> CONNECTIONS_FEATURE_DISABLED
  143, // 4 -> STALE_SDK_VERSION
  34, // 5 -> FEATURE_BLUETOOTH_NOT_SUPPORTED
  33, // 6 -> FEATURE_BLUETOOTH_LE_NOT_SUPPORTED
  98, // 7 -> NULL_BLUETOOTH_MANAGER
  92, // 8 -> NULL_BLUETOOTH_ADAPTER
  55, // 9 -> INVALID_FAST_PAIR_MODEL_ID
  54, // 10 -> INVALID_FAST_ADVERTISEMENT_DATA
  48, // 11 -> INVALID_ADVERTISEMENT_HEADER_DATA
  62, // 12 -> INVALID_REGULAR_ADVERTISEMENT_DATA
  96, // 13 -> NULL_BLUETOOTH_LE_ADVERTISER_COMPAT
  2, // 14 -> ADVERTISE_FAILED_ALREADY_STARTED
  3, // 15 -> ADVERTISE_FAILED_DATA_TOO_LARGE
  4, // 16 -> ADVERTISE_FAILED_FEATURE_UNSUPPORTED
  5, // 17 -> ADVERTISE_FAILED_INTERNAL_ERROR
  6, // 18 -> ADVERTISE_FAILED_TOO_MANY_ADVERTISERS
  47, // 19 -> INTERRUPTED_EXCEPTION
  31, // 20 -> EXECUTION_EXCEPTION
  94, // 21 -> NULL_BLUETOOTH_DEVICE_NAME
  135, // 22 -> SET_SCAN_MODE_FAILED
  66, // 23 -> INVOKE_API_FAILED
  157, // 24 -> TIMEOUT
  106, // 25 -> NULL_NFC_TAG
  36, // 26 -> FEATURE_NFC_NOT_SUPPORTED
  35, // 27 -> FEATURE_NFC_HOST_CARD_EMULATION_NOT_SUPPORTED
  71, // 30 -> MULTICAST_NOT_SUPPORTED
  88, // 31 -> NSD_NOT_ENABLED
  61, // 32 -> INVALID_PORT_NUMBER
  110, // 33 -> NULL_SERVICE_NAME
  111, // 34 -> NULL_SERVICE_TYPE
  183, // 35 -> WITHOUT_CONNECTED_WIFI_NETWORK
  40, // 36 -> FEATURE_WIFI_AWARE_NOT_SUPPORTED
  101, // 37 -> NULL_CONNECTIVITY_MANAGER
  113, // 38 -> NULL_WIFI_AWARE_MANAGER
  142, // 39 -> STALE_ANDROID_VERSION
  109, // 40 -> NULL_SERVICE_INFO
  117, // 41 -> NULL_WORK_SOURCE
  100, // 42 -> NULL_CALLBACK
  97, // 43 -> NULL_BLUETOOTH_LE_SCANNER_COMPAT
  30, // 44 -> EMPTY_WORK_SOURCE_CACHE
  126, // 45 -> SCAN_FAILED_ALREADY_STARTED
  127, // 46 -> SCAN_FAILED_APPLICATION_REGISTRATION_FAILED
  130, // 47 -> SCAN_FAILED_INTERNAL_ERROR
  129, // 48 -> SCAN_FAILED_FEATURE_UNSUPPORTED
  128, // 49 -> SCAN_FAILED_BLUETOOTH_DISABLED
  131, // 50 -> SCAN_FILTERS_NOT_ALLOWED_FOR_LOCATION
  19, // 51 -> BLUETOOTH_SCAN_REJUVENATE_FAILED
  91, // 52 -> NULL_BLE_PERIPHERAL
  95, // 53 -> NULL_BLUETOOTH_GATT
  158, // 54 -> UNEXPECTED_BLUETOOTH_STATE
  125, // 55 -> REMOTE_EXCEPTION
  53, // 56 -> INVALID_BLUETOOTH_SOCKET_STATE_BEFORE_CONNECT
  20, // 57 -> BLUETOOTH_SOCKET_CLOSED_AFTER_CONNECTED
  50, // 58 -> INVALID_BLUETOOTH_CHANNEL
  93, // 59 -> NULL_BLUETOOTH_DEVICE
  99, // 60 -> NULL_BLUETOOTH_PROXY
  60, // 61 -> INVALID_PACKET_LENGTH
  59, // 62 -> INVALID_PACKET_BYTES
  159, // 63 -> UNEXPECTED_EOF_EXCEPTION
  140, // 64 -> SOCKET_CLOSED_OR_TIMEOUT
  56, // 65 -> INVALID_IPV4_ADDRESS
  57, // 66 -> INVALID_IPV6_ADDRESS
  89, // 67 -> NULL_ADDRESS
  64, // 68 -> INVALID_VERSION
  133, // 69 -> SET_CONNECTION_PRIORITY_FAILED
  134, // 70 -> SET_CONNECTION_PRIORITY_INTERRUPTED
  163, // 71 -> UNKNOWN_IO_EXCEPTION
  123, // 72 -> READ_CHARACTERISTIC_FAILED
  177, // 73 -> WIFI_HOTSPOT_ENABLED
  16, // 74 -> AWARE_UNAVAILABLE
  67, // 75 -> IN_BLACK_LIST
  42, // 76 -> FEATURE_WIFI_NOT_SUPPORTED
  115, // 77 -> NULL_WIFI_MANAGER
  139, // 78 -> SOCKET_CLOSED
  137, // 79 -> SOCKET_ALREADY_CONNECTED
  86, // 80 -> NFC_TECH_NOT_SUPPORTED
  85, // 81 -> NFC_SERVICE_DIED
  18, // 82 -> BIND_NFC_SERVICE_FAILED
  84, // 83 -> NFC_CREATE_SOCKET_FAILED
  114, // 84 -> NULL_WIFI_AWARE_PEER
  80, // 85 -> NETWORK_ALREADY_JOINED
  69, // 86 -> JOIN_AWARE_NETWORK_CANCELLED
  83, // 87 -> NETWORK_UNAVAILABLE
  181, // 88 -> WITHOUT_ACTIVE_AWARE_NETWORK
  184, // 89 -> WITHOUT_JOINED_AWARE_NETWORK
  27, // 90 -> CONNET_TO_SOCKET_CANCELLED
  112, // 91 -> NULL_SSID
  107, // 92 -> NULL_PASSWORD
  41, // 93 -> FEATURE_WIFI_DIRECT_NOT_SUPPORTED
  116, // 94 -> NULL_WIFI_P2P_MANAGER
  118, // 95 -> P2P_GROUP_FORMED
  0, // 96 -> ACQUIRE_P2P_CHANNEL_FAILED
  119, // 97 -> P2P_UNSUPPORTED
  46, // 98 -> INTERNAL_ERROR
  23, // 99 -> BUSY
  124, // 100 -> REFLECTION_ERROR
  81, // 101 -> NETWORK_ERROR_EHOSTUNREACH
  82, // 102 -> NETWORK_ERROR_ENETUNREACH
  1, // 103 -> ADD_NETWORK_FAILED
  172, // 104 -> UPDATE_NETWORK_FAILED
  8, // 105 -> ALREADY_IN_PROGRESS
  49, // 106 -> INVALID_ARGS
  87, // 107 -> NOT_AUTHORIZED
  58, // 108 -> INVALID_NETWORK_ID
  178, // 109 -> WIFI_MANAGER_ENABLE_NETWORK_FAILED
  179, // 110 -> WIFI_MANAGER_RECONNECT_FAILED
  182, // 111 -> WITHOUT_ACTIVE_NETWORK
  175, // 112 -> WEBRTC_CONNECTION_FLOW_EXIST
  103, // 113 -> NULL_DROID_GUARD_RESULT
  155, // 114 -> TACHYON_SIGNALING_MESSENGER_EXIST
  144, // 115 -> TACHYON_ALREADY_START_RECEIVE_MESSAGE
  149, // 116 -> TACHYON_RECEIVE_MESSAGE_FAILED
  150, // 117 -> TACHYON_RECEIVE_MESSAGE_INTERRUPTED
  148, // 118 -> TACHYON_RECEIVE_MESSAGE_EXECUTION_EXCEPTION
  152, // 119 -> TACHYON_RECEIVE_MESSAGE_TIMEOUT
  147, // 120 -> TACHYON_RECEIVE_MESSAGE_AUTH_EXCEPTION
  151, // 121 -> TACHYON_RECEIVE_MESSAGE_STATUS_EXCEPTION
  153, // 122 -> TACHYON_SEND_MESSAGE_AUTH_EXCEPTION
  154, // 123 -> TACHYON_SEND_MESSAGE_STATUS_EXCEPTION
  145, // 124 -> TACHYON_GET_ICE_SERVER_AUTH_EXCEPTION
  146, // 125 -> TACHYON_GET_ICE_SERVER_STATUS_EXCEPTION
  29, // 126 -> EMPTY_TACHYON_ICE_SERVER
  121, // 127 -> POTENTIAL_WEBRTC_LIB_LOADING_FAILURE
  160, // 128 -> UNEXPECTED_GATT_DESCRIPTOR
  32, // 129 -> FAIL_TO_RECEIVE_L2CAP_PACKET
  185, // 130 -> WITHOUT_PSM_VALUE
  138, // 131 -> SOCKET_BIND_LISTEN_FAILED
  161, // 132 -> UNEXPECTED_PACKET_CONTENT
  164, // 133 -> UNREGISTER_NSD_MANAGER_FAILED
  122, // 134 -> PUBLISH_EMPTY_ADVERTISEMENT_FAILED
  21, // 135 -> BLUETOOTH_SOCKET_NOT_IN_LISTENING_STATE
  51, // 136 -> INVALID_BLUETOOTH_SOCKET_SIGNAL_SIZE
  52, // 137 -> INVALID_BLUETOOTH_SOCKET_SIGNAL_STATUS
  43, // 138 -> GET_ADDRESS_FAILED
  104, // 139 -> NULL_LOCAL_ADDRESS
  68, // 140 -> IS_LOOPBACK_ADDRESS
  141, // 141 -> SOCKET_NOT_BOUND
  63, // 142 -> INVALID_REMOTE_ADDRESS
  136, // 143 -> SOCKET_ALREADY_BOUND
  45, // 144 -> HOTSPOT_NOT_STARTED
  174, // 145 -> WEBRTC_ALREADY_INITIALIZED
  65, // 146 -> INVALID_WEBRTC_STATE
  102, // 147 -> NULL_DATA_CHANNEL
  28, // 148 -> CREATE_OFFER_FAILED
  24, // 149 -> CLOSE_SERVER_SOCKET_FAILED
  176, // 150 -> WIFI_AWARE_STARTED
  14, // 151 -> AWARE_PUBLISH_SESSION_RAN_OUT
  15, // 152 -> AWARE_SUBSCRIBE_SESSION_RAN_OUT
  9, // 153 -> AWARE_DATA_PATH_RAN_OUT
  180, // 154 -> WIFI_SIGNAL_STRENGTH_POOR
  120, // 155 -> POTENTIAL_SRD_ISSUE
  11, // 156 -> AWARE_L2_MESSAGE_HOST_NETWORK_ERROR
  13, // 157 -> AWARE_L2_MESSAGE_NETWORK_AVAILABLE_ERROR
  12, // 158 -> AWARE_L2_MESSAGE_IP_AVAILABLE_ERROR
  10, // 159 -> AWARE_L2_MESSAGE_CANCELLATION_RECEIVED
  156, // 160 -> TIE_BREAK_LOSER
  132, // 161 -> SERVER_SOCKET_UNAVAILABLE
  44, // 162 -> HOSTED_NETWORK_UNAVAILABLE
  17, // 163 -> AWARE_UPDATE_PUBLISHING_CONFIG_FAILED
  70, // 164 -> L2CAP_UNAVAILABLE
  7, // 165 -> ALREADY_HAS_GATT_CONNECTION
  165, // 166 -> UNSUPPORTED_DEVICE_TYPE
  167, // 167 -> UNSUPPORTED_DEVICE_TYPE_CHROME_OS
  166, // 168 -> UNSUPPORTED_DEVICE_TYPE_AUTO
  170, // 169 -> UNSUPPORTED_DEVICE_TYPE_TV
  171, // 170 -> UNSUPPORTED_DEVICE_TYPE_WEAR
  105, // 171 -> NULL_MESSAGE
  173, // 172 -> USER_RESTRICTION_DISALLOWED
  168, // 173 -> UNSUPPORTED_DEVICE_TYPE_PHONE
  169, // 174 -> UNSUPPORTED_DEVICE_TYPE_TABLET
  22, // 175 -> BROKEN_PIPE
  26, // 176 -> CONNECTION_ABORT
  38, // 177 -> FEATURE_USB_HOST_NOT_SUPPORTED
  37, // 178 -> FEATURE_USB_ACCESSORY_NOT_SUPPORTED
  39, // 179 -> FEATURE_USB_PORTS_NOT_FOUND
  78, // 180 -> MULTIPLEX_SOCKET_UNKNOWN_ERROR
  76, // 181 -> MULTIPLEX_SOCKET_NOT_LISTENING
  72, // 182 -> MULTIPLEX_SOCKET_DISABLED
  77, // 183 -> MULTIPLEX_SOCKET_TIMEOUT
  75, // 184 -> MULTIPLEX_SOCKET_IOEXCEPTION
  79, // 185 -> MULTIPLEX_SOCKET_UNKNOWN_RESPONSE_CODE
  73, // 186 -> MULTIPLEX_SOCKET_EXECUTION_EXCEPTION
  74, // 187 -> MULTIPLEX_SOCKET_INTERRUPTED_EXCEPTION
};

const std::string& Description_Name(
    Description value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          Description_entries,
          Description_entries_by_number,
          186, Description_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      Description_entries,
      Description_entries_by_number,
      186, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     Description_strings[idx].get();
}
bool Description_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Description* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      Description_entries, 186, name, &int_value);
  if (success) {
    *value = static_cast<Description>(int_value);
  }
  return success;
}

// @@protoc_insertion_point(namespace_scope)
}  // namespace proto
}  // namespace errorcode
}  // namespace nearby
}  // namespace location
PROTOBUF_NAMESPACE_OPEN
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>