// 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:
      return true;
    default:
      return false;
  }
}

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

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";

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 },
};

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
};

const std::string& Event_Name(
    Event value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          Event_entries,
          Event_entries_by_number,
          14, Event_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      Event_entries,
      Event_entries_by_number,
      14, 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, 14, 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 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:
      return true;
    default:
      return false;
  }
}

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

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"
  "BUSY"
  "CLOSE_SERVER_SOCKET_FAILED"
  "CONNECTIONS_FEATURE_DISABLED"
  "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_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"
  "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_TV"
  "UNSUPPORTED_DEVICE_TYPE_WEAR"
  "UPDATE_NETWORK_FAILED"
  "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, 4}, 99 },
  { {Description_names + 679, 26}, 149 },
  { {Description_names + 705, 28}, 3 },
  { {Description_names + 733, 26}, 90 },
  { {Description_names + 759, 19}, 148 },
  { {Description_names + 778, 24}, 126 },
  { {Description_names + 802, 23}, 44 },
  { {Description_names + 825, 19}, 20 },
  { {Description_names + 844, 28}, 129 },
  { {Description_names + 872, 34}, 6 },
  { {Description_names + 906, 31}, 5 },
  { {Description_names + 937, 45}, 27 },
  { {Description_names + 982, 25}, 26 },
  { {Description_names + 1007, 32}, 36 },
  { {Description_names + 1039, 33}, 93 },
  { {Description_names + 1072, 26}, 76 },
  { {Description_names + 1098, 18}, 138 },
  { {Description_names + 1116, 26}, 162 },
  { {Description_names + 1142, 19}, 144 },
  { {Description_names + 1161, 14}, 98 },
  { {Description_names + 1175, 21}, 19 },
  { {Description_names + 1196, 33}, 11 },
  { {Description_names + 1229, 12}, 106 },
  { {Description_names + 1241, 25}, 58 },
  { {Description_names + 1266, 36}, 136 },
  { {Description_names + 1302, 38}, 137 },
  { {Description_names + 1340, 45}, 56 },
  { {Description_names + 1385, 31}, 10 },
  { {Description_names + 1416, 26}, 9 },
  { {Description_names + 1442, 20}, 65 },
  { {Description_names + 1462, 20}, 66 },
  { {Description_names + 1482, 18}, 108 },
  { {Description_names + 1500, 20}, 62 },
  { {Description_names + 1520, 21}, 61 },
  { {Description_names + 1541, 19}, 32 },
  { {Description_names + 1560, 34}, 12 },
  { {Description_names + 1594, 22}, 142 },
  { {Description_names + 1616, 15}, 68 },
  { {Description_names + 1631, 20}, 146 },
  { {Description_names + 1651, 17}, 23 },
  { {Description_names + 1668, 13}, 75 },
  { {Description_names + 1681, 19}, 140 },
  { {Description_names + 1700, 28}, 86 },
  { {Description_names + 1728, 17}, 164 },
  { {Description_names + 1745, 23}, 30 },
  { {Description_names + 1768, 22}, 85 },
  { {Description_names + 1790, 26}, 101 },
  { {Description_names + 1816, 25}, 102 },
  { {Description_names + 1841, 19}, 87 },
  { {Description_names + 1860, 24}, 83 },
  { {Description_names + 1884, 16}, 81 },
  { {Description_names + 1900, 22}, 80 },
  { {Description_names + 1922, 14}, 107 },
  { {Description_names + 1936, 15}, 31 },
  { {Description_names + 1951, 12}, 67 },
  { {Description_names + 1963, 24}, 2 },
  { {Description_names + 1987, 19}, 52 },
  { {Description_names + 2006, 22}, 8 },
  { {Description_names + 2028, 21}, 59 },
  { {Description_names + 2049, 26}, 21 },
  { {Description_names + 2075, 19}, 53 },
  { {Description_names + 2094, 35}, 13 },
  { {Description_names + 2129, 32}, 43 },
  { {Description_names + 2161, 22}, 7 },
  { {Description_names + 2183, 20}, 60 },
  { {Description_names + 2203, 13}, 42 },
  { {Description_names + 2216, 25}, 37 },
  { {Description_names + 2241, 17}, 147 },
  { {Description_names + 2258, 23}, 113 },
  { {Description_names + 2281, 18}, 139 },
  { {Description_names + 2299, 12}, 171 },
  { {Description_names + 2311, 12}, 25 },
  { {Description_names + 2323, 13}, 92 },
  { {Description_names + 2336, 15}, 1 },
  { {Description_names + 2351, 17}, 40 },
  { {Description_names + 2368, 17}, 33 },
  { {Description_names + 2385, 17}, 34 },
  { {Description_names + 2402, 9}, 91 },
  { {Description_names + 2411, 23}, 38 },
  { {Description_names + 2434, 20}, 84 },
  { {Description_names + 2454, 17}, 77 },
  { {Description_names + 2471, 21}, 94 },
  { {Description_names + 2492, 16}, 41 },
  { {Description_names + 2508, 16}, 95 },
  { {Description_names + 2524, 15}, 97 },
  { {Description_names + 2539, 19}, 155 },
  { {Description_names + 2558, 36}, 127 },
  { {Description_names + 2594, 34}, 134 },
  { {Description_names + 2628, 26}, 72 },
  { {Description_names + 2654, 16}, 100 },
  { {Description_names + 2670, 16}, 55 },
  { {Description_names + 2686, 27}, 45 },
  { {Description_names + 2713, 43}, 46 },
  { {Description_names + 2756, 30}, 49 },
  { {Description_names + 2786, 31}, 48 },
  { {Description_names + 2817, 26}, 47 },
  { {Description_names + 2843, 37}, 50 },
  { {Description_names + 2880, 25}, 161 },
  { {Description_names + 2905, 30}, 69 },
  { {Description_names + 2935, 35}, 70 },
  { {Description_names + 2970, 20}, 22 },
  { {Description_names + 2990, 20}, 143 },
  { {Description_names + 3010, 24}, 79 },
  { {Description_names + 3034, 25}, 131 },
  { {Description_names + 3059, 13}, 78 },
  { {Description_names + 3072, 24}, 64 },
  { {Description_names + 3096, 16}, 141 },
  { {Description_names + 3112, 21}, 39 },
  { {Description_names + 3133, 17}, 4 },
  { {Description_names + 3150, 37}, 115 },
  { {Description_names + 3187, 37}, 124 },
  { {Description_names + 3224, 39}, 125 },
  { {Description_names + 3263, 38}, 120 },
  { {Description_names + 3301, 43}, 118 },
  { {Description_names + 3344, 30}, 116 },
  { {Description_names + 3374, 35}, 117 },
  { {Description_names + 3409, 40}, 121 },
  { {Description_names + 3449, 31}, 119 },
  { {Description_names + 3480, 35}, 122 },
  { {Description_names + 3515, 37}, 123 },
  { {Description_names + 3552, 33}, 114 },
  { {Description_names + 3585, 15}, 160 },
  { {Description_names + 3600, 7}, 24 },
  { {Description_names + 3607, 26}, 54 },
  { {Description_names + 3633, 24}, 63 },
  { {Description_names + 3657, 26}, 128 },
  { {Description_names + 3683, 25}, 132 },
  { {Description_names + 3708, 7}, 0 },
  { {Description_names + 3715, 20}, 71 },
  { {Description_names + 3735, 29}, 133 },
  { {Description_names + 3764, 23}, 166 },
  { {Description_names + 3787, 28}, 168 },
  { {Description_names + 3815, 33}, 167 },
  { {Description_names + 3848, 26}, 169 },
  { {Description_names + 3874, 28}, 170 },
  { {Description_names + 3902, 21}, 104 },
  { {Description_names + 3923, 26}, 145 },
  { {Description_names + 3949, 28}, 112 },
  { {Description_names + 3977, 18}, 150 },
  { {Description_names + 3995, 20}, 73 },
  { {Description_names + 4015, 34}, 109 },
  { {Description_names + 4049, 29}, 110 },
  { {Description_names + 4078, 25}, 154 },
  { {Description_names + 4103, 28}, 88 },
  { {Description_names + 4131, 22}, 111 },
  { {Description_names + 4153, 30}, 35 },
  { {Description_names + 4183, 28}, 89 },
  { {Description_names + 4211, 17}, 130 },
};

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

const std::string& Description_Name(
    Description value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          Description_entries,
          Description_entries_by_number,
          170, Description_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      Description_entries,
      Description_entries_by_number,
      170, 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, 170, 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>