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

#include "proto/sharing_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 proto {
namespace sharing {
}  // namespace sharing
}  // namespace proto
}  // namespace nearby
}  // namespace location
namespace location {
namespace nearby {
namespace proto {
namespace sharing {
bool EventType_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 28:
    case 29:
    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:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> EventType_strings[74] = {};

static const char EventType_names[] =
  "ACCEPT_AGREEMENTS"
  "ACCEPT_FAST_INITIALIZATION"
  "ADD_CONTACT"
  "ADD_QUICK_SETTINGS_TILE"
  "ADVERTISE_DEVICE_PRESENCE_END"
  "ADVERTISE_DEVICE_PRESENCE_START"
  "APP_CRASH"
  "AUTO_DISMISS_FAST_INITIALIZATION"
  "CANCEL_CONNECTION"
  "CANCEL_RECEIVING_ATTACHMENTS"
  "CANCEL_SENDING_ATTACHMENTS"
  "DECLINE_AGREEMENTS"
  "DECRYPT_CERTIFICATE_FAILURE"
  "DEFAULT_OPT_IN"
  "DESCRIBE_ATTACHMENTS"
  "DEVICE_SETTINGS"
  "DISCOVER_SHARE_TARGET"
  "DISMISS_FAST_INITIALIZATION"
  "DISMISS_PRIVACY_NOTIFICATION"
  "DISPLAY_PHONE_CONSENT"
  "DISPLAY_PRIVACY_NOTIFICATION"
  "ENABLE_NEARBY_SHARING"
  "ESTABLISH_CONNECTION"
  "FAST_INIT_DISCOVER_DEVICE"
  "FAST_SHARE_SERVER_RESPONSE"
  "HATS_JOINT_EVENT"
  "HIGH_QUALITY_MEDIUM_SETUP"
  "INSTALL_APK"
  "LAUNCH_ACTIVITY"
  "LAUNCH_CONSENT"
  "LAUNCH_PHONE_CONSENT"
  "LAUNCH_SETUP_ACTIVITY"
  "OPEN_RECEIVED_ATTACHMENTS"
  "PARSING_FAILED_ENDPOINT_ID"
  "PREFERENCES_USAGE"
  "PROCESS_RECEIVED_ATTACHMENTS_END"
  "QR_CODE_LINK_SHOWN"
  "QR_CODE_OPENED_IN_WEB_CLIENT"
  "RECEIVE_ATTACHMENTS_END"
  "RECEIVE_ATTACHMENTS_START"
  "RECEIVE_FAST_INITIALIZATION"
  "RECEIVE_INTRODUCTION"
  "RECEIVE_PREVIEWS"
  "REMOVE_CONTACT"
  "REMOVE_QUICK_SETTINGS_TILE"
  "REQUEST_SETTING_PERMISSIONS"
  "RESPOND_TO_INTRODUCTION"
  "RPC_CALL_STATUS"
  "SCAN_FOR_SHARE_TARGETS_END"
  "SCAN_FOR_SHARE_TARGETS_START"
  "SEND_ATTACHMENTS_END"
  "SEND_ATTACHMENTS_START"
  "SEND_DESKTOP_NOTIFICATION"
  "SEND_DESKTOP_TRANSFER_EVENT"
  "SEND_FAST_INITIALIZATION"
  "SEND_INTRODUCTION"
  "SEND_START"
  "SETUP_WIZARD"
  "SET_ACCOUNT"
  "SET_DATA_USAGE"
  "SET_DEVICE_NAME"
  "SET_VISIBILITY"
  "SHOW_ALLOW_PERMISSION_AUTO_ACCESS"
  "START_QR_CODE_SESSION"
  "TAP_FEEDBACK"
  "TAP_HELP"
  "TAP_PRIVACY_NOTIFICATION"
  "TAP_QR_CODE"
  "TAP_QUICK_SETTINGS_FILE_SHARE"
  "TAP_QUICK_SETTINGS_TILE"
  "TOGGLE_SHOW_NOTIFICATION"
  "UNKNOWN_EVENT_TYPE"
  "VERIFY_APK"
  "WAITING_FOR_ACCEPT";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry EventType_entries[] = {
  { {EventType_names + 0, 17}, 1 },
  { {EventType_names + 17, 26}, 27 },
  { {EventType_names + 43, 11}, 23 },
  { {EventType_names + 54, 23}, 36 },
  { {EventType_names + 77, 29}, 8 },
  { {EventType_names + 106, 31}, 7 },
  { {EventType_names + 137, 9}, 51 },
  { {EventType_names + 146, 32}, 50 },
  { {EventType_names + 178, 17}, 30 },
  { {EventType_names + 195, 28}, 20 },
  { {EventType_names + 223, 26}, 19 },
  { {EventType_names + 249, 18}, 46 },
  { {EventType_names + 267, 27}, 64 },
  { {EventType_names + 294, 14}, 56 },
  { {EventType_names + 308, 20}, 4 },
  { {EventType_names + 328, 15}, 49 },
  { {EventType_names + 343, 21}, 11 },
  { {EventType_names + 364, 27}, 29 },
  { {EventType_names + 391, 28}, 32 },
  { {EventType_names + 419, 21}, 54 },
  { {EventType_names + 440, 28}, 53 },
  { {EventType_names + 468, 21}, 2 },
  { {EventType_names + 489, 20}, 48 },
  { {EventType_names + 509, 25}, 61 },
  { {EventType_names + 534, 26}, 25 },
  { {EventType_names + 560, 16}, 72 },
  { {EventType_names + 576, 25}, 68 },
  { {EventType_names + 601, 11}, 40 },
  { {EventType_names + 612, 15}, 31 },
  { {EventType_names + 627, 14}, 42 },
  { {EventType_names + 641, 20}, 38 },
  { {EventType_names + 661, 21}, 22 },
  { {EventType_names + 682, 25}, 21 },
  { {EventType_names + 707, 26}, 60 },
  { {EventType_names + 733, 17}, 55 },
  { {EventType_names + 750, 32}, 43 },
  { {EventType_names + 782, 18}, 59 },
  { {EventType_names + 800, 28}, 71 },
  { {EventType_names + 828, 23}, 18 },
  { {EventType_names + 851, 25}, 17 },
  { {EventType_names + 876, 27}, 10 },
  { {EventType_names + 903, 20}, 13 },
  { {EventType_names + 923, 16}, 73 },
  { {EventType_names + 939, 14}, 24 },
  { {EventType_names + 953, 26}, 37 },
  { {EventType_names + 979, 27}, 47 },
  { {EventType_names + 1006, 23}, 14 },
  { {EventType_names + 1029, 15}, 69 },
  { {EventType_names + 1044, 26}, 6 },
  { {EventType_names + 1070, 28}, 5 },
  { {EventType_names + 1098, 20}, 16 },
  { {EventType_names + 1118, 22}, 15 },
  { {EventType_names + 1140, 25}, 62 },
  { {EventType_names + 1165, 27}, 66 },
  { {EventType_names + 1192, 24}, 9 },
  { {EventType_names + 1216, 17}, 12 },
  { {EventType_names + 1233, 10}, 26 },
  { {EventType_names + 1243, 12}, 57 },
  { {EventType_names + 1255, 11}, 63 },
  { {EventType_names + 1266, 14}, 28 },
  { {EventType_names + 1280, 15}, 45 },
  { {EventType_names + 1295, 14}, 3 },
  { {EventType_names + 1309, 33}, 65 },
  { {EventType_names + 1342, 21}, 70 },
  { {EventType_names + 1363, 12}, 35 },
  { {EventType_names + 1375, 8}, 34 },
  { {EventType_names + 1383, 24}, 33 },
  { {EventType_names + 1407, 11}, 58 },
  { {EventType_names + 1418, 29}, 52 },
  { {EventType_names + 1447, 23}, 39 },
  { {EventType_names + 1470, 24}, 44 },
  { {EventType_names + 1494, 18}, 0 },
  { {EventType_names + 1512, 10}, 41 },
  { {EventType_names + 1522, 18}, 67 },
};

static const int EventType_entries_by_number[] = {
  71, // 0 -> UNKNOWN_EVENT_TYPE
  0, // 1 -> ACCEPT_AGREEMENTS
  21, // 2 -> ENABLE_NEARBY_SHARING
  61, // 3 -> SET_VISIBILITY
  14, // 4 -> DESCRIBE_ATTACHMENTS
  49, // 5 -> SCAN_FOR_SHARE_TARGETS_START
  48, // 6 -> SCAN_FOR_SHARE_TARGETS_END
  5, // 7 -> ADVERTISE_DEVICE_PRESENCE_START
  4, // 8 -> ADVERTISE_DEVICE_PRESENCE_END
  54, // 9 -> SEND_FAST_INITIALIZATION
  40, // 10 -> RECEIVE_FAST_INITIALIZATION
  16, // 11 -> DISCOVER_SHARE_TARGET
  55, // 12 -> SEND_INTRODUCTION
  41, // 13 -> RECEIVE_INTRODUCTION
  46, // 14 -> RESPOND_TO_INTRODUCTION
  51, // 15 -> SEND_ATTACHMENTS_START
  50, // 16 -> SEND_ATTACHMENTS_END
  39, // 17 -> RECEIVE_ATTACHMENTS_START
  38, // 18 -> RECEIVE_ATTACHMENTS_END
  10, // 19 -> CANCEL_SENDING_ATTACHMENTS
  9, // 20 -> CANCEL_RECEIVING_ATTACHMENTS
  32, // 21 -> OPEN_RECEIVED_ATTACHMENTS
  31, // 22 -> LAUNCH_SETUP_ACTIVITY
  2, // 23 -> ADD_CONTACT
  43, // 24 -> REMOVE_CONTACT
  24, // 25 -> FAST_SHARE_SERVER_RESPONSE
  56, // 26 -> SEND_START
  1, // 27 -> ACCEPT_FAST_INITIALIZATION
  59, // 28 -> SET_DATA_USAGE
  17, // 29 -> DISMISS_FAST_INITIALIZATION
  8, // 30 -> CANCEL_CONNECTION
  28, // 31 -> LAUNCH_ACTIVITY
  18, // 32 -> DISMISS_PRIVACY_NOTIFICATION
  66, // 33 -> TAP_PRIVACY_NOTIFICATION
  65, // 34 -> TAP_HELP
  64, // 35 -> TAP_FEEDBACK
  3, // 36 -> ADD_QUICK_SETTINGS_TILE
  44, // 37 -> REMOVE_QUICK_SETTINGS_TILE
  30, // 38 -> LAUNCH_PHONE_CONSENT
  69, // 39 -> TAP_QUICK_SETTINGS_TILE
  27, // 40 -> INSTALL_APK
  72, // 41 -> VERIFY_APK
  29, // 42 -> LAUNCH_CONSENT
  35, // 43 -> PROCESS_RECEIVED_ATTACHMENTS_END
  70, // 44 -> TOGGLE_SHOW_NOTIFICATION
  60, // 45 -> SET_DEVICE_NAME
  11, // 46 -> DECLINE_AGREEMENTS
  45, // 47 -> REQUEST_SETTING_PERMISSIONS
  22, // 48 -> ESTABLISH_CONNECTION
  15, // 49 -> DEVICE_SETTINGS
  7, // 50 -> AUTO_DISMISS_FAST_INITIALIZATION
  6, // 51 -> APP_CRASH
  68, // 52 -> TAP_QUICK_SETTINGS_FILE_SHARE
  20, // 53 -> DISPLAY_PRIVACY_NOTIFICATION
  19, // 54 -> DISPLAY_PHONE_CONSENT
  34, // 55 -> PREFERENCES_USAGE
  13, // 56 -> DEFAULT_OPT_IN
  57, // 57 -> SETUP_WIZARD
  67, // 58 -> TAP_QR_CODE
  36, // 59 -> QR_CODE_LINK_SHOWN
  33, // 60 -> PARSING_FAILED_ENDPOINT_ID
  23, // 61 -> FAST_INIT_DISCOVER_DEVICE
  52, // 62 -> SEND_DESKTOP_NOTIFICATION
  58, // 63 -> SET_ACCOUNT
  12, // 64 -> DECRYPT_CERTIFICATE_FAILURE
  62, // 65 -> SHOW_ALLOW_PERMISSION_AUTO_ACCESS
  53, // 66 -> SEND_DESKTOP_TRANSFER_EVENT
  73, // 67 -> WAITING_FOR_ACCEPT
  26, // 68 -> HIGH_QUALITY_MEDIUM_SETUP
  47, // 69 -> RPC_CALL_STATUS
  63, // 70 -> START_QR_CODE_SESSION
  37, // 71 -> QR_CODE_OPENED_IN_WEB_CLIENT
  25, // 72 -> HATS_JOINT_EVENT
  42, // 73 -> RECEIVE_PREVIEWS
};

const std::string& EventType_Name(
    EventType value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          EventType_entries,
          EventType_entries_by_number,
          74, EventType_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      EventType_entries,
      EventType_entries_by_number,
      74, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     EventType_strings[idx].get();
}
bool EventType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, EventType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      EventType_entries, 74, name, &int_value);
  if (success) {
    *value = static_cast<EventType>(int_value);
  }
  return success;
}
bool EventCategory_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}

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

static const char EventCategory_names[] =
  "RECEIVING_EVENT"
  "RPC_EVENT"
  "SENDING_EVENT"
  "SETTINGS_EVENT"
  "UNKNOWN_EVENT_CATEGORY";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry EventCategory_entries[] = {
  { {EventCategory_names + 0, 15}, 2 },
  { {EventCategory_names + 15, 9}, 4 },
  { {EventCategory_names + 24, 13}, 1 },
  { {EventCategory_names + 37, 14}, 3 },
  { {EventCategory_names + 51, 22}, 0 },
};

static const int EventCategory_entries_by_number[] = {
  4, // 0 -> UNKNOWN_EVENT_CATEGORY
  2, // 1 -> SENDING_EVENT
  0, // 2 -> RECEIVING_EVENT
  3, // 3 -> SETTINGS_EVENT
  1, // 4 -> RPC_EVENT
};

const std::string& EventCategory_Name(
    EventCategory value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          EventCategory_entries,
          EventCategory_entries_by_number,
          5, EventCategory_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      EventCategory_entries,
      EventCategory_entries_by_number,
      5, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     EventCategory_strings[idx].get();
}
bool EventCategory_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, EventCategory* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      EventCategory_entries, 5, name, &int_value);
  if (success) {
    *value = static_cast<EventCategory>(int_value);
  }
  return success;
}
bool NearbySharingStatus_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> NearbySharingStatus_strings[3] = {};

static const char NearbySharingStatus_names[] =
  "OFF"
  "ON"
  "UNKNOWN_NEARBY_SHARING_STATUS";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry NearbySharingStatus_entries[] = {
  { {NearbySharingStatus_names + 0, 3}, 2 },
  { {NearbySharingStatus_names + 3, 2}, 1 },
  { {NearbySharingStatus_names + 5, 29}, 0 },
};

static const int NearbySharingStatus_entries_by_number[] = {
  2, // 0 -> UNKNOWN_NEARBY_SHARING_STATUS
  1, // 1 -> ON
  0, // 2 -> OFF
};

const std::string& NearbySharingStatus_Name(
    NearbySharingStatus value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          NearbySharingStatus_entries,
          NearbySharingStatus_entries_by_number,
          3, NearbySharingStatus_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      NearbySharingStatus_entries,
      NearbySharingStatus_entries_by_number,
      3, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     NearbySharingStatus_strings[idx].get();
}
bool NearbySharingStatus_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, NearbySharingStatus* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      NearbySharingStatus_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<NearbySharingStatus>(int_value);
  }
  return success;
}
bool Visibility_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> Visibility_strings[6] = {};

static const char Visibility_names[] =
  "CONTACTS_ONLY"
  "EVERYONE"
  "HIDDEN"
  "SELECTED_CONTACTS_ONLY"
  "SELF_SHARE"
  "UNKNOWN_VISIBILITY";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry Visibility_entries[] = {
  { {Visibility_names + 0, 13}, 1 },
  { {Visibility_names + 13, 8}, 2 },
  { {Visibility_names + 21, 6}, 4 },
  { {Visibility_names + 27, 22}, 3 },
  { {Visibility_names + 49, 10}, 5 },
  { {Visibility_names + 59, 18}, 0 },
};

static const int Visibility_entries_by_number[] = {
  5, // 0 -> UNKNOWN_VISIBILITY
  0, // 1 -> CONTACTS_ONLY
  1, // 2 -> EVERYONE
  3, // 3 -> SELECTED_CONTACTS_ONLY
  2, // 4 -> HIDDEN
  4, // 5 -> SELF_SHARE
};

const std::string& Visibility_Name(
    Visibility value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          Visibility_entries,
          Visibility_entries_by_number,
          6, Visibility_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      Visibility_entries,
      Visibility_entries_by_number,
      6, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     Visibility_strings[idx].get();
}
bool Visibility_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Visibility* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      Visibility_entries, 6, name, &int_value);
  if (success) {
    *value = static_cast<Visibility>(int_value);
  }
  return success;
}
bool DataUsage_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

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

static const char DataUsage_names[] =
  "OFFLINE"
  "ONLINE"
  "UNKNOWN_DATA_USAGE"
  "WIFI_ONLY";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry DataUsage_entries[] = {
  { {DataUsage_names + 0, 7}, 3 },
  { {DataUsage_names + 7, 6}, 1 },
  { {DataUsage_names + 13, 18}, 0 },
  { {DataUsage_names + 31, 9}, 2 },
};

static const int DataUsage_entries_by_number[] = {
  2, // 0 -> UNKNOWN_DATA_USAGE
  1, // 1 -> ONLINE
  3, // 2 -> WIFI_ONLY
  0, // 3 -> OFFLINE
};

const std::string& DataUsage_Name(
    DataUsage value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          DataUsage_entries,
          DataUsage_entries_by_number,
          4, DataUsage_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      DataUsage_entries,
      DataUsage_entries_by_number,
      4, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     DataUsage_strings[idx].get();
}
bool DataUsage_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DataUsage* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      DataUsage_entries, 4, name, &int_value);
  if (success) {
    *value = static_cast<DataUsage>(int_value);
  }
  return success;
}
bool EstablishConnectionStatus_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:
      return true;
    default:
      return false;
  }
}

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

static const char EstablishConnectionStatus_names[] =
  "CONNECTION_STATUS_CANCELLATION"
  "CONNECTION_STATUS_FAILED_NO_TRANSFER_UPDATE_CALLBACK"
  "CONNECTION_STATUS_FAILED_NULL_CONNECTION"
  "CONNECTION_STATUS_FAILED_PAIRED_KEYHANDSHAKE"
  "CONNECTION_STATUS_FAILED_WRITE_INTRODUCTION"
  "CONNECTION_STATUS_FAILURE"
  "CONNECTION_STATUS_INVALID_ADVERTISEMENT"
  "CONNECTION_STATUS_LOST_CONNECTIVITY"
  "CONNECTION_STATUS_MEDIA_UNAVAILABLE_ATTACHMENT"
  "CONNECTION_STATUS_SUCCESS"
  "CONNECTION_STATUS_UNKNOWN";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry EstablishConnectionStatus_entries[] = {
  { {EstablishConnectionStatus_names + 0, 30}, 3 },
  { {EstablishConnectionStatus_names + 30, 52}, 8 },
  { {EstablishConnectionStatus_names + 82, 40}, 7 },
  { {EstablishConnectionStatus_names + 122, 44}, 5 },
  { {EstablishConnectionStatus_names + 166, 43}, 6 },
  { {EstablishConnectionStatus_names + 209, 25}, 2 },
  { {EstablishConnectionStatus_names + 234, 39}, 10 },
  { {EstablishConnectionStatus_names + 273, 35}, 9 },
  { {EstablishConnectionStatus_names + 308, 46}, 4 },
  { {EstablishConnectionStatus_names + 354, 25}, 1 },
  { {EstablishConnectionStatus_names + 379, 25}, 0 },
};

static const int EstablishConnectionStatus_entries_by_number[] = {
  10, // 0 -> CONNECTION_STATUS_UNKNOWN
  9, // 1 -> CONNECTION_STATUS_SUCCESS
  5, // 2 -> CONNECTION_STATUS_FAILURE
  0, // 3 -> CONNECTION_STATUS_CANCELLATION
  8, // 4 -> CONNECTION_STATUS_MEDIA_UNAVAILABLE_ATTACHMENT
  3, // 5 -> CONNECTION_STATUS_FAILED_PAIRED_KEYHANDSHAKE
  4, // 6 -> CONNECTION_STATUS_FAILED_WRITE_INTRODUCTION
  2, // 7 -> CONNECTION_STATUS_FAILED_NULL_CONNECTION
  1, // 8 -> CONNECTION_STATUS_FAILED_NO_TRANSFER_UPDATE_CALLBACK
  7, // 9 -> CONNECTION_STATUS_LOST_CONNECTIVITY
  6, // 10 -> CONNECTION_STATUS_INVALID_ADVERTISEMENT
};

const std::string& EstablishConnectionStatus_Name(
    EstablishConnectionStatus value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          EstablishConnectionStatus_entries,
          EstablishConnectionStatus_entries_by_number,
          11, EstablishConnectionStatus_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      EstablishConnectionStatus_entries,
      EstablishConnectionStatus_entries_by_number,
      11, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     EstablishConnectionStatus_strings[idx].get();
}
bool EstablishConnectionStatus_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, EstablishConnectionStatus* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      EstablishConnectionStatus_entries, 11, name, &int_value);
  if (success) {
    *value = static_cast<EstablishConnectionStatus>(int_value);
  }
  return success;
}
bool AttachmentTransmissionStatus_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 28:
    case 29:
    case 30:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> AttachmentTransmissionStatus_strings[31] = {};

static const char AttachmentTransmissionStatus_names[] =
  "AWAITING_REMOTE_ACCEPTANCE_FAILED_ATTACHMENT"
  "CANCELED_ATTACHMENT_TRANSMISSION_STATUS"
  "COMPLETE_ATTACHMENT_TRANSMISSION_STATUS"
  "FAILED_ATTACHMENT_TRANSMISSION_STATUS"
  "FAILED_DISALLOWED_MEDIUM"
  "FAILED_NO_PAYLOAD"
  "FAILED_NO_SHARE_TARGET_ENDPOINT"
  "FAILED_NO_TRANSFER_UPDATE_CALLBACK"
  "FAILED_NULL_CONNECTION"
  "FAILED_NULL_CONNECTION_DISCONNECTED"
  "FAILED_NULL_CONNECTION_FAILURE"
  "FAILED_NULL_CONNECTION_INIT_OUTGOING"
  "FAILED_NULL_CONNECTION_LOST_CONNECTIVITY"
  "FAILED_PAIRED_KEYHANDSHAKE"
  "FAILED_UNKNOWN_REMOTE_RESPONSE"
  "FAILED_UNKNOWN_REMOTE_RESPONSE_TRANSMISSION_STATUS"
  "FAILED_WRITE_INTRODUCTION"
  "LOST_CONNECTIVITY_TRANSMISSION_STATUS"
  "MEDIA_UNAVAILABLE_ATTACHMENT"
  "NOT_ENOUGH_SPACE_ATTACHMENT"
  "NOT_ENOUGH_SPACE_ATTACHMENT_TRANSMISSION_STATUS"
  "NO_ATTACHMENT_FOUND"
  "NO_RESPONSE_FRAME_CONNECTION_CLOSED_LOST_CONNECTIVITY_TRANSMISSION_STATUS"
  "NO_RESPONSE_FRAME_CONNECTION_CLOSED_TRANSMISSION_STATUS"
  "REJECTED_ATTACHMENT"
  "REJECTED_ATTACHMENT_TRANSMISSION_STATUS"
  "TIMED_OUT_ATTACHMENT"
  "TIMED_OUT_ATTACHMENT_TRANSMISSION_STATUS"
  "UNKNOWN_ATTACHMENT_TRANSMISSION_STATUS"
  "UNSUPPORTED_ATTACHMENT_TYPE_ATTACHMENT"
  "UNSUPPORTED_ATTACHMENT_TYPE_ATTACHMENT_TRANSMISSION_STATUS";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry AttachmentTransmissionStatus_entries[] = {
  { {AttachmentTransmissionStatus_names + 0, 44}, 6 },
  { {AttachmentTransmissionStatus_names + 44, 39}, 2 },
  { {AttachmentTransmissionStatus_names + 83, 39}, 1 },
  { {AttachmentTransmissionStatus_names + 122, 37}, 3 },
  { {AttachmentTransmissionStatus_names + 159, 24}, 30 },
  { {AttachmentTransmissionStatus_names + 183, 17}, 15 },
  { {AttachmentTransmissionStatus_names + 200, 31}, 12 },
  { {AttachmentTransmissionStatus_names + 231, 34}, 8 },
  { {AttachmentTransmissionStatus_names + 265, 22}, 14 },
  { {AttachmentTransmissionStatus_names + 287, 35}, 19 },
  { {AttachmentTransmissionStatus_names + 322, 30}, 21 },
  { {AttachmentTransmissionStatus_names + 352, 36}, 18 },
  { {AttachmentTransmissionStatus_names + 388, 40}, 20 },
  { {AttachmentTransmissionStatus_names + 428, 26}, 13 },
  { {AttachmentTransmissionStatus_names + 454, 30}, 17 },
  { {AttachmentTransmissionStatus_names + 484, 50}, 26 },
  { {AttachmentTransmissionStatus_names + 534, 25}, 16 },
  { {AttachmentTransmissionStatus_names + 559, 37}, 29 },
  { {AttachmentTransmissionStatus_names + 596, 28}, 9 },
  { {AttachmentTransmissionStatus_names + 624, 27}, 7 },
  { {AttachmentTransmissionStatus_names + 651, 47}, 24 },
  { {AttachmentTransmissionStatus_names + 698, 19}, 11 },
  { {AttachmentTransmissionStatus_names + 717, 73}, 27 },
  { {AttachmentTransmissionStatus_names + 790, 55}, 28 },
  { {AttachmentTransmissionStatus_names + 845, 19}, 4 },
  { {AttachmentTransmissionStatus_names + 864, 39}, 22 },
  { {AttachmentTransmissionStatus_names + 903, 20}, 5 },
  { {AttachmentTransmissionStatus_names + 923, 40}, 23 },
  { {AttachmentTransmissionStatus_names + 963, 38}, 0 },
  { {AttachmentTransmissionStatus_names + 1001, 38}, 10 },
  { {AttachmentTransmissionStatus_names + 1039, 58}, 25 },
};

static const int AttachmentTransmissionStatus_entries_by_number[] = {
  28, // 0 -> UNKNOWN_ATTACHMENT_TRANSMISSION_STATUS
  2, // 1 -> COMPLETE_ATTACHMENT_TRANSMISSION_STATUS
  1, // 2 -> CANCELED_ATTACHMENT_TRANSMISSION_STATUS
  3, // 3 -> FAILED_ATTACHMENT_TRANSMISSION_STATUS
  24, // 4 -> REJECTED_ATTACHMENT
  26, // 5 -> TIMED_OUT_ATTACHMENT
  0, // 6 -> AWAITING_REMOTE_ACCEPTANCE_FAILED_ATTACHMENT
  19, // 7 -> NOT_ENOUGH_SPACE_ATTACHMENT
  7, // 8 -> FAILED_NO_TRANSFER_UPDATE_CALLBACK
  18, // 9 -> MEDIA_UNAVAILABLE_ATTACHMENT
  29, // 10 -> UNSUPPORTED_ATTACHMENT_TYPE_ATTACHMENT
  21, // 11 -> NO_ATTACHMENT_FOUND
  6, // 12 -> FAILED_NO_SHARE_TARGET_ENDPOINT
  13, // 13 -> FAILED_PAIRED_KEYHANDSHAKE
  8, // 14 -> FAILED_NULL_CONNECTION
  5, // 15 -> FAILED_NO_PAYLOAD
  16, // 16 -> FAILED_WRITE_INTRODUCTION
  14, // 17 -> FAILED_UNKNOWN_REMOTE_RESPONSE
  11, // 18 -> FAILED_NULL_CONNECTION_INIT_OUTGOING
  9, // 19 -> FAILED_NULL_CONNECTION_DISCONNECTED
  12, // 20 -> FAILED_NULL_CONNECTION_LOST_CONNECTIVITY
  10, // 21 -> FAILED_NULL_CONNECTION_FAILURE
  25, // 22 -> REJECTED_ATTACHMENT_TRANSMISSION_STATUS
  27, // 23 -> TIMED_OUT_ATTACHMENT_TRANSMISSION_STATUS
  20, // 24 -> NOT_ENOUGH_SPACE_ATTACHMENT_TRANSMISSION_STATUS
  30, // 25 -> UNSUPPORTED_ATTACHMENT_TYPE_ATTACHMENT_TRANSMISSION_STATUS
  15, // 26 -> FAILED_UNKNOWN_REMOTE_RESPONSE_TRANSMISSION_STATUS
  22, // 27 -> NO_RESPONSE_FRAME_CONNECTION_CLOSED_LOST_CONNECTIVITY_TRANSMISSION_STATUS
  23, // 28 -> NO_RESPONSE_FRAME_CONNECTION_CLOSED_TRANSMISSION_STATUS
  17, // 29 -> LOST_CONNECTIVITY_TRANSMISSION_STATUS
  4, // 30 -> FAILED_DISALLOWED_MEDIUM
};

const std::string& AttachmentTransmissionStatus_Name(
    AttachmentTransmissionStatus value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          AttachmentTransmissionStatus_entries,
          AttachmentTransmissionStatus_entries_by_number,
          31, AttachmentTransmissionStatus_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      AttachmentTransmissionStatus_entries,
      AttachmentTransmissionStatus_entries_by_number,
      31, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     AttachmentTransmissionStatus_strings[idx].get();
}
bool AttachmentTransmissionStatus_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AttachmentTransmissionStatus* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      AttachmentTransmissionStatus_entries, 31, name, &int_value);
  if (success) {
    *value = static_cast<AttachmentTransmissionStatus>(int_value);
  }
  return success;
}
bool ConnectionLayerStatus_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:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ConnectionLayerStatus_strings[19] = {};

static const char ConnectionLayerStatus_names[] =
  "CONNECTION_LAYER_STATUS_ALREADY_ADVERTISING"
  "CONNECTION_LAYER_STATUS_ALREADY_CONNECTED_TO_END_POINT"
  "CONNECTION_LAYER_STATUS_ALREADY_DISCOVERING"
  "CONNECTION_LAYER_STATUS_ALREADY_HAVE_ACTIVE_STRATEGY"
  "CONNECTION_LAYER_STATUS_ALREADY_LISTENING"
  "CONNECTION_LAYER_STATUS_BLE_ERROR"
  "CONNECTION_LAYER_STATUS_BLUETOOTH_ERROR"
  "CONNECTION_LAYER_STATUS_CONNECTION_REJECTED"
  "CONNECTION_LAYER_STATUS_END_POINT_IO_ERROR"
  "CONNECTION_LAYER_STATUS_END_POINT_UNKNOWN"
  "CONNECTION_LAYER_STATUS_ERROR"
  "CONNECTION_LAYER_STATUS_NOT_CONNECTED_TO_END_POINT"
  "CONNECTION_LAYER_STATUS_OUT_OF_ORDER_API_CALL"
  "CONNECTION_LAYER_STATUS_PAYLOAD_UNKNOWN"
  "CONNECTION_LAYER_STATUS_RESET"
  "CONNECTION_LAYER_STATUS_SUCCESS"
  "CONNECTION_LAYER_STATUS_TIMEOUT"
  "CONNECTION_LAYER_STATUS_UNKNOWN"
  "CONNECTION_LAYER_STATUS_WIFI_LAN_ERROR";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ConnectionLayerStatus_entries[] = {
  { {ConnectionLayerStatus_names + 0, 43}, 5 },
  { {ConnectionLayerStatus_names + 43, 54}, 11 },
  { {ConnectionLayerStatus_names + 97, 43}, 6 },
  { {ConnectionLayerStatus_names + 140, 52}, 4 },
  { {ConnectionLayerStatus_names + 192, 41}, 7 },
  { {ConnectionLayerStatus_names + 233, 33}, 14 },
  { {ConnectionLayerStatus_names + 266, 39}, 13 },
  { {ConnectionLayerStatus_names + 305, 43}, 10 },
  { {ConnectionLayerStatus_names + 348, 42}, 8 },
  { {ConnectionLayerStatus_names + 390, 41}, 9 },
  { {ConnectionLayerStatus_names + 431, 29}, 2 },
  { {ConnectionLayerStatus_names + 460, 50}, 12 },
  { {ConnectionLayerStatus_names + 510, 45}, 3 },
  { {ConnectionLayerStatus_names + 555, 39}, 16 },
  { {ConnectionLayerStatus_names + 594, 29}, 17 },
  { {ConnectionLayerStatus_names + 623, 31}, 1 },
  { {ConnectionLayerStatus_names + 654, 31}, 18 },
  { {ConnectionLayerStatus_names + 685, 31}, 0 },
  { {ConnectionLayerStatus_names + 716, 38}, 15 },
};

static const int ConnectionLayerStatus_entries_by_number[] = {
  17, // 0 -> CONNECTION_LAYER_STATUS_UNKNOWN
  15, // 1 -> CONNECTION_LAYER_STATUS_SUCCESS
  10, // 2 -> CONNECTION_LAYER_STATUS_ERROR
  12, // 3 -> CONNECTION_LAYER_STATUS_OUT_OF_ORDER_API_CALL
  3, // 4 -> CONNECTION_LAYER_STATUS_ALREADY_HAVE_ACTIVE_STRATEGY
  0, // 5 -> CONNECTION_LAYER_STATUS_ALREADY_ADVERTISING
  2, // 6 -> CONNECTION_LAYER_STATUS_ALREADY_DISCOVERING
  4, // 7 -> CONNECTION_LAYER_STATUS_ALREADY_LISTENING
  8, // 8 -> CONNECTION_LAYER_STATUS_END_POINT_IO_ERROR
  9, // 9 -> CONNECTION_LAYER_STATUS_END_POINT_UNKNOWN
  7, // 10 -> CONNECTION_LAYER_STATUS_CONNECTION_REJECTED
  1, // 11 -> CONNECTION_LAYER_STATUS_ALREADY_CONNECTED_TO_END_POINT
  11, // 12 -> CONNECTION_LAYER_STATUS_NOT_CONNECTED_TO_END_POINT
  6, // 13 -> CONNECTION_LAYER_STATUS_BLUETOOTH_ERROR
  5, // 14 -> CONNECTION_LAYER_STATUS_BLE_ERROR
  18, // 15 -> CONNECTION_LAYER_STATUS_WIFI_LAN_ERROR
  13, // 16 -> CONNECTION_LAYER_STATUS_PAYLOAD_UNKNOWN
  14, // 17 -> CONNECTION_LAYER_STATUS_RESET
  16, // 18 -> CONNECTION_LAYER_STATUS_TIMEOUT
};

const std::string& ConnectionLayerStatus_Name(
    ConnectionLayerStatus value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          ConnectionLayerStatus_entries,
          ConnectionLayerStatus_entries_by_number,
          19, ConnectionLayerStatus_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      ConnectionLayerStatus_entries,
      ConnectionLayerStatus_entries_by_number,
      19, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     ConnectionLayerStatus_strings[idx].get();
}
bool ConnectionLayerStatus_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConnectionLayerStatus* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      ConnectionLayerStatus_entries, 19, name, &int_value);
  if (success) {
    *value = static_cast<ConnectionLayerStatus>(int_value);
  }
  return success;
}
bool ProcessReceivedAttachmentsStatus_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> ProcessReceivedAttachmentsStatus_strings[6] = {};

static const char ProcessReceivedAttachmentsStatus_names[] =
  "PROCESSING_STATUS_COMPLETE_PROCESSING_ATTACHMENTS"
  "PROCESSING_STATUS_FAILED_MOVING_FILES"
  "PROCESSING_STATUS_FAILED_RECEIVING_APK"
  "PROCESSING_STATUS_FAILED_RECEIVING_TEXT"
  "PROCESSING_STATUS_FAILED_RECEIVING_WIFI_CREDENTIALS"
  "PROCESSING_STATUS_UNKNOWN";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ProcessReceivedAttachmentsStatus_entries[] = {
  { {ProcessReceivedAttachmentsStatus_names + 0, 49}, 1 },
  { {ProcessReceivedAttachmentsStatus_names + 49, 37}, 2 },
  { {ProcessReceivedAttachmentsStatus_names + 86, 38}, 3 },
  { {ProcessReceivedAttachmentsStatus_names + 124, 39}, 4 },
  { {ProcessReceivedAttachmentsStatus_names + 163, 51}, 5 },
  { {ProcessReceivedAttachmentsStatus_names + 214, 25}, 0 },
};

static const int ProcessReceivedAttachmentsStatus_entries_by_number[] = {
  5, // 0 -> PROCESSING_STATUS_UNKNOWN
  0, // 1 -> PROCESSING_STATUS_COMPLETE_PROCESSING_ATTACHMENTS
  1, // 2 -> PROCESSING_STATUS_FAILED_MOVING_FILES
  2, // 3 -> PROCESSING_STATUS_FAILED_RECEIVING_APK
  3, // 4 -> PROCESSING_STATUS_FAILED_RECEIVING_TEXT
  4, // 5 -> PROCESSING_STATUS_FAILED_RECEIVING_WIFI_CREDENTIALS
};

const std::string& ProcessReceivedAttachmentsStatus_Name(
    ProcessReceivedAttachmentsStatus value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          ProcessReceivedAttachmentsStatus_entries,
          ProcessReceivedAttachmentsStatus_entries_by_number,
          6, ProcessReceivedAttachmentsStatus_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      ProcessReceivedAttachmentsStatus_entries,
      ProcessReceivedAttachmentsStatus_entries_by_number,
      6, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     ProcessReceivedAttachmentsStatus_strings[idx].get();
}
bool ProcessReceivedAttachmentsStatus_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ProcessReceivedAttachmentsStatus* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      ProcessReceivedAttachmentsStatus_entries, 6, name, &int_value);
  if (success) {
    *value = static_cast<ProcessReceivedAttachmentsStatus>(int_value);
  }
  return success;
}
bool SessionStatus_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> SessionStatus_strings[3] = {};

static const char SessionStatus_names[] =
  "FAILED_SESSION_STATUS"
  "SUCCEEDED_SESSION_STATUS"
  "UNKNOWN_SESSION_STATUS";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry SessionStatus_entries[] = {
  { {SessionStatus_names + 0, 21}, 2 },
  { {SessionStatus_names + 21, 24}, 1 },
  { {SessionStatus_names + 45, 22}, 0 },
};

static const int SessionStatus_entries_by_number[] = {
  2, // 0 -> UNKNOWN_SESSION_STATUS
  1, // 1 -> SUCCEEDED_SESSION_STATUS
  0, // 2 -> FAILED_SESSION_STATUS
};

const std::string& SessionStatus_Name(
    SessionStatus value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          SessionStatus_entries,
          SessionStatus_entries_by_number,
          3, SessionStatus_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      SessionStatus_entries,
      SessionStatus_entries_by_number,
      3, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     SessionStatus_strings[idx].get();
}
bool SessionStatus_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SessionStatus* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      SessionStatus_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<SessionStatus>(int_value);
  }
  return success;
}
bool ResponseToIntroduction_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

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

static const char ResponseToIntroduction_names[] =
  "ACCEPT_INTRODUCTION"
  "FAIL_INTRODUCTION"
  "REJECT_INTRODUCTION"
  "UNKNOWN_RESPONSE_TO_INTRODUCTION";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ResponseToIntroduction_entries[] = {
  { {ResponseToIntroduction_names + 0, 19}, 1 },
  { {ResponseToIntroduction_names + 19, 17}, 3 },
  { {ResponseToIntroduction_names + 36, 19}, 2 },
  { {ResponseToIntroduction_names + 55, 32}, 0 },
};

static const int ResponseToIntroduction_entries_by_number[] = {
  3, // 0 -> UNKNOWN_RESPONSE_TO_INTRODUCTION
  0, // 1 -> ACCEPT_INTRODUCTION
  2, // 2 -> REJECT_INTRODUCTION
  1, // 3 -> FAIL_INTRODUCTION
};

const std::string& ResponseToIntroduction_Name(
    ResponseToIntroduction value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          ResponseToIntroduction_entries,
          ResponseToIntroduction_entries_by_number,
          4, ResponseToIntroduction_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      ResponseToIntroduction_entries,
      ResponseToIntroduction_entries_by_number,
      4, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     ResponseToIntroduction_strings[idx].get();
}
bool ResponseToIntroduction_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ResponseToIntroduction* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      ResponseToIntroduction_entries, 4, name, &int_value);
  if (success) {
    *value = static_cast<ResponseToIntroduction>(int_value);
  }
  return success;
}
bool DeviceType_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> DeviceType_strings[7] = {};

static const char DeviceType_names[] =
  "CAR"
  "FOLDABLE"
  "LAPTOP"
  "PHONE"
  "TABLET"
  "UNKNOWN_DEVICE_TYPE"
  "XR";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry DeviceType_entries[] = {
  { {DeviceType_names + 0, 3}, 4 },
  { {DeviceType_names + 3, 8}, 5 },
  { {DeviceType_names + 11, 6}, 3 },
  { {DeviceType_names + 17, 5}, 1 },
  { {DeviceType_names + 22, 6}, 2 },
  { {DeviceType_names + 28, 19}, 0 },
  { {DeviceType_names + 47, 2}, 6 },
};

static const int DeviceType_entries_by_number[] = {
  5, // 0 -> UNKNOWN_DEVICE_TYPE
  3, // 1 -> PHONE
  4, // 2 -> TABLET
  2, // 3 -> LAPTOP
  0, // 4 -> CAR
  1, // 5 -> FOLDABLE
  6, // 6 -> XR
};

const std::string& DeviceType_Name(
    DeviceType value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          DeviceType_entries,
          DeviceType_entries_by_number,
          7, DeviceType_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      DeviceType_entries,
      DeviceType_entries_by_number,
      7, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     DeviceType_strings[idx].get();
}
bool DeviceType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      DeviceType_entries, 7, name, &int_value);
  if (success) {
    *value = static_cast<DeviceType>(int_value);
  }
  return success;
}
bool OSType_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> OSType_strings[6] = {};

static const char OSType_names[] =
  "ANDROID"
  "CHROME_OS"
  "IOS"
  "MACOS"
  "UNKNOWN_OS_TYPE"
  "WINDOWS";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry OSType_entries[] = {
  { {OSType_names + 0, 7}, 1 },
  { {OSType_names + 7, 9}, 2 },
  { {OSType_names + 16, 3}, 3 },
  { {OSType_names + 19, 5}, 5 },
  { {OSType_names + 24, 15}, 0 },
  { {OSType_names + 39, 7}, 4 },
};

static const int OSType_entries_by_number[] = {
  4, // 0 -> UNKNOWN_OS_TYPE
  0, // 1 -> ANDROID
  1, // 2 -> CHROME_OS
  2, // 3 -> IOS
  5, // 4 -> WINDOWS
  3, // 5 -> MACOS
};

const std::string& OSType_Name(
    OSType value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          OSType_entries,
          OSType_entries_by_number,
          6, OSType_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      OSType_entries,
      OSType_entries_by_number,
      6, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     OSType_strings[idx].get();
}
bool OSType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OSType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      OSType_entries, 6, name, &int_value);
  if (success) {
    *value = static_cast<OSType>(int_value);
  }
  return success;
}
bool DeviceRelationship_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

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

static const char DeviceRelationship_names[] =
  "IS_CONTACT"
  "IS_SELF"
  "IS_STRANGER"
  "UNKNOWN_DEVICE_RELATIONSHIP";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry DeviceRelationship_entries[] = {
  { {DeviceRelationship_names + 0, 10}, 2 },
  { {DeviceRelationship_names + 10, 7}, 1 },
  { {DeviceRelationship_names + 17, 11}, 3 },
  { {DeviceRelationship_names + 28, 27}, 0 },
};

static const int DeviceRelationship_entries_by_number[] = {
  3, // 0 -> UNKNOWN_DEVICE_RELATIONSHIP
  1, // 1 -> IS_SELF
  0, // 2 -> IS_CONTACT
  2, // 3 -> IS_STRANGER
};

const std::string& DeviceRelationship_Name(
    DeviceRelationship value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          DeviceRelationship_entries,
          DeviceRelationship_entries_by_number,
          4, DeviceRelationship_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      DeviceRelationship_entries,
      DeviceRelationship_entries_by_number,
      4, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     DeviceRelationship_strings[idx].get();
}
bool DeviceRelationship_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceRelationship* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      DeviceRelationship_entries, 4, name, &int_value);
  if (success) {
    *value = static_cast<DeviceRelationship>(int_value);
  }
  return success;
}
bool LogSource_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:
      return true;
    default:
      return false;
  }
}

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

static const char LogSource_names[] =
  "BETA_TESTER_DEVICES"
  "BETO_DOGFOOD_DEVICES"
  "DEBUG_DEVICES"
  "INTERNAL_DEVICES"
  "LAB_DEVICES"
  "NEARBY_DOGFOOD_DEVICES"
  "NEARBY_MODULE_FOOD_DEVICES"
  "NEARBY_TEAMFOOD_DEVICES"
  "OEM_DEVICES"
  "UNSPECIFIED_SOURCE";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry LogSource_entries[] = {
  { {LogSource_names + 0, 19}, 3 },
  { {LogSource_names + 19, 20}, 7 },
  { {LogSource_names + 39, 13}, 5 },
  { {LogSource_names + 52, 16}, 2 },
  { {LogSource_names + 68, 11}, 1 },
  { {LogSource_names + 79, 22}, 8 },
  { {LogSource_names + 101, 26}, 6 },
  { {LogSource_names + 127, 23}, 9 },
  { {LogSource_names + 150, 11}, 4 },
  { {LogSource_names + 161, 18}, 0 },
};

static const int LogSource_entries_by_number[] = {
  9, // 0 -> UNSPECIFIED_SOURCE
  4, // 1 -> LAB_DEVICES
  3, // 2 -> INTERNAL_DEVICES
  0, // 3 -> BETA_TESTER_DEVICES
  8, // 4 -> OEM_DEVICES
  2, // 5 -> DEBUG_DEVICES
  6, // 6 -> NEARBY_MODULE_FOOD_DEVICES
  1, // 7 -> BETO_DOGFOOD_DEVICES
  5, // 8 -> NEARBY_DOGFOOD_DEVICES
  7, // 9 -> NEARBY_TEAMFOOD_DEVICES
};

const std::string& LogSource_Name(
    LogSource value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          LogSource_entries,
          LogSource_entries_by_number,
          10, LogSource_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      LogSource_entries,
      LogSource_entries_by_number,
      10, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     LogSource_strings[idx].get();
}
bool LogSource_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LogSource* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      LogSource_entries, 10, name, &int_value);
  if (success) {
    *value = static_cast<LogSource>(int_value);
  }
  return success;
}
bool ServerActionName_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:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ServerActionName_strings[13] = {};

static const char ServerActionName_names[] =
  "CHECK_REACHABILITY"
  "DOWNLOAD_CERTIFICATES"
  "DOWNLOAD_CERTIFICATES_INFO"
  "DOWNLOAD_SENDER_CERTIFICATES"
  "LIST_CONTACT_PEOPLE"
  "LIST_MY_DEVICES"
  "LIST_REACHABLE_PHONE_NUMBERS"
  "UNKNOWN_SERVER_ACTION"
  "UPDATE_DEVICE_NAME"
  "UPLOAD_CERTIFICATES"
  "UPLOAD_CONTACTS"
  "UPLOAD_CONTACTS_AND_CERTIFICATES"
  "UPLOAD_SENDER_CERTIFICATES";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ServerActionName_entries[] = {
  { {ServerActionName_names + 0, 18}, 3 },
  { {ServerActionName_names + 18, 21}, 2 },
  { {ServerActionName_names + 39, 26}, 12 },
  { {ServerActionName_names + 65, 28}, 7 },
  { {ServerActionName_names + 93, 19}, 11 },
  { {ServerActionName_names + 112, 15}, 10 },
  { {ServerActionName_names + 127, 28}, 9 },
  { {ServerActionName_names + 155, 21}, 0 },
  { {ServerActionName_names + 176, 18}, 5 },
  { {ServerActionName_names + 194, 19}, 1 },
  { {ServerActionName_names + 213, 15}, 4 },
  { {ServerActionName_names + 228, 32}, 8 },
  { {ServerActionName_names + 260, 26}, 6 },
};

static const int ServerActionName_entries_by_number[] = {
  7, // 0 -> UNKNOWN_SERVER_ACTION
  9, // 1 -> UPLOAD_CERTIFICATES
  1, // 2 -> DOWNLOAD_CERTIFICATES
  0, // 3 -> CHECK_REACHABILITY
  10, // 4 -> UPLOAD_CONTACTS
  8, // 5 -> UPDATE_DEVICE_NAME
  12, // 6 -> UPLOAD_SENDER_CERTIFICATES
  3, // 7 -> DOWNLOAD_SENDER_CERTIFICATES
  11, // 8 -> UPLOAD_CONTACTS_AND_CERTIFICATES
  6, // 9 -> LIST_REACHABLE_PHONE_NUMBERS
  5, // 10 -> LIST_MY_DEVICES
  4, // 11 -> LIST_CONTACT_PEOPLE
  2, // 12 -> DOWNLOAD_CERTIFICATES_INFO
};

const std::string& ServerActionName_Name(
    ServerActionName value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          ServerActionName_entries,
          ServerActionName_entries_by_number,
          13, ServerActionName_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      ServerActionName_entries,
      ServerActionName_entries_by_number,
      13, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     ServerActionName_strings[idx].get();
}
bool ServerActionName_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ServerActionName* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      ServerActionName_entries, 13, name, &int_value);
  if (success) {
    *value = static_cast<ServerActionName>(int_value);
  }
  return success;
}
bool ServerResponseState_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:
      return true;
    default:
      return false;
  }
}

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

static const char ServerResponseState_names[] =
  "SERVER_RESPONSE_GOOGLE_AUTH_FAILURE"
  "SERVER_RESPONSE_NOT_CONNECTED_TO_INTERNET"
  "SERVER_RESPONSE_STATUS_DEADLINE_EXCEEDED"
  "SERVER_RESPONSE_STATUS_INVALID_ARGUMENT"
  "SERVER_RESPONSE_STATUS_OTHER_FAILURE"
  "SERVER_RESPONSE_STATUS_PERMISSION_DENIED"
  "SERVER_RESPONSE_STATUS_UNAUTHENTICATED"
  "SERVER_RESPONSE_STATUS_UNAVAILABLE"
  "SERVER_RESPONSE_SUCCESS"
  "SERVER_RESPONSE_UNKNOWN_FAILURE"
  "UNKNOWN_SERVER_RESPONSE_STATE";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ServerResponseState_entries[] = {
  { {ServerResponseState_names + 0, 35}, 8 },
  { {ServerResponseState_names + 35, 41}, 10 },
  { {ServerResponseState_names + 76, 40}, 4 },
  { {ServerResponseState_names + 116, 39}, 9 },
  { {ServerResponseState_names + 155, 36}, 3 },
  { {ServerResponseState_names + 191, 40}, 5 },
  { {ServerResponseState_names + 231, 38}, 7 },
  { {ServerResponseState_names + 269, 34}, 6 },
  { {ServerResponseState_names + 303, 23}, 1 },
  { {ServerResponseState_names + 326, 31}, 2 },
  { {ServerResponseState_names + 357, 29}, 0 },
};

static const int ServerResponseState_entries_by_number[] = {
  10, // 0 -> UNKNOWN_SERVER_RESPONSE_STATE
  8, // 1 -> SERVER_RESPONSE_SUCCESS
  9, // 2 -> SERVER_RESPONSE_UNKNOWN_FAILURE
  4, // 3 -> SERVER_RESPONSE_STATUS_OTHER_FAILURE
  2, // 4 -> SERVER_RESPONSE_STATUS_DEADLINE_EXCEEDED
  5, // 5 -> SERVER_RESPONSE_STATUS_PERMISSION_DENIED
  7, // 6 -> SERVER_RESPONSE_STATUS_UNAVAILABLE
  6, // 7 -> SERVER_RESPONSE_STATUS_UNAUTHENTICATED
  0, // 8 -> SERVER_RESPONSE_GOOGLE_AUTH_FAILURE
  3, // 9 -> SERVER_RESPONSE_STATUS_INVALID_ARGUMENT
  1, // 10 -> SERVER_RESPONSE_NOT_CONNECTED_TO_INTERNET
};

const std::string& ServerResponseState_Name(
    ServerResponseState value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          ServerResponseState_entries,
          ServerResponseState_entries_by_number,
          11, ServerResponseState_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      ServerResponseState_entries,
      ServerResponseState_entries_by_number,
      11, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     ServerResponseState_strings[idx].get();
}
bool ServerResponseState_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ServerResponseState* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      ServerResponseState_entries, 11, name, &int_value);
  if (success) {
    *value = static_cast<ServerResponseState>(int_value);
  }
  return success;
}
bool SyncPurpose_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:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> SyncPurpose_strings[18] = {};

static const char SyncPurpose_names[] =
  "SYNC_PURPOSE_ACCOUNT_CHANGE"
  "SYNC_PURPOSE_CHECK_DEFAULT_OPT_IN"
  "SYNC_PURPOSE_CHIME_NOTIFICATION"
  "SYNC_PURPOSE_CONTACT_LIST_CHANGE"
  "SYNC_PURPOSE_DAILY_SYNC"
  "SYNC_PURPOSE_DEVICE_CONTACTS_CONSENT_CHANGE"
  "SYNC_PURPOSE_NEARBY_SHARE_ENABLED"
  "SYNC_PURPOSE_ON_DEMAND_SYNC"
  "SYNC_PURPOSE_OPT_IN_FIRST_SYNC"
  "SYNC_PURPOSE_REGENERATE_CERTIFICATES"
  "SYNC_PURPOSE_REGULAR_CHECK_CONTACT_REACHABILITY"
  "SYNC_PURPOSE_SHOW_C11N_VIEW"
  "SYNC_PURPOSE_SYNC_AT_ADVERTISEMENT"
  "SYNC_PURPOSE_SYNC_AT_DISCOVERY"
  "SYNC_PURPOSE_SYNC_AT_FAST_INIT"
  "SYNC_PURPOSE_SYNC_AT_LOAD_PRIVATE_CERTIFICATE"
  "SYNC_PURPOSE_UNKNOWN"
  "SYNC_PURPOSE_VISIBILITY_SELECTED_CONTACT_CHANGE";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry SyncPurpose_entries[] = {
  { {SyncPurpose_names + 0, 27}, 15 },
  { {SyncPurpose_names + 27, 33}, 5 },
  { {SyncPurpose_names + 60, 31}, 2 },
  { {SyncPurpose_names + 91, 32}, 11 },
  { {SyncPurpose_names + 123, 23}, 3 },
  { {SyncPurpose_names + 146, 43}, 17 },
  { {SyncPurpose_names + 189, 33}, 6 },
  { {SyncPurpose_names + 222, 27}, 1 },
  { {SyncPurpose_names + 249, 30}, 4 },
  { {SyncPurpose_names + 279, 36}, 16 },
  { {SyncPurpose_names + 315, 47}, 13 },
  { {SyncPurpose_names + 362, 27}, 12 },
  { {SyncPurpose_names + 389, 34}, 10 },
  { {SyncPurpose_names + 423, 30}, 8 },
  { {SyncPurpose_names + 453, 30}, 7 },
  { {SyncPurpose_names + 483, 45}, 9 },
  { {SyncPurpose_names + 528, 20}, 0 },
  { {SyncPurpose_names + 548, 47}, 14 },
};

static const int SyncPurpose_entries_by_number[] = {
  16, // 0 -> SYNC_PURPOSE_UNKNOWN
  7, // 1 -> SYNC_PURPOSE_ON_DEMAND_SYNC
  2, // 2 -> SYNC_PURPOSE_CHIME_NOTIFICATION
  4, // 3 -> SYNC_PURPOSE_DAILY_SYNC
  8, // 4 -> SYNC_PURPOSE_OPT_IN_FIRST_SYNC
  1, // 5 -> SYNC_PURPOSE_CHECK_DEFAULT_OPT_IN
  6, // 6 -> SYNC_PURPOSE_NEARBY_SHARE_ENABLED
  14, // 7 -> SYNC_PURPOSE_SYNC_AT_FAST_INIT
  13, // 8 -> SYNC_PURPOSE_SYNC_AT_DISCOVERY
  15, // 9 -> SYNC_PURPOSE_SYNC_AT_LOAD_PRIVATE_CERTIFICATE
  12, // 10 -> SYNC_PURPOSE_SYNC_AT_ADVERTISEMENT
  3, // 11 -> SYNC_PURPOSE_CONTACT_LIST_CHANGE
  11, // 12 -> SYNC_PURPOSE_SHOW_C11N_VIEW
  10, // 13 -> SYNC_PURPOSE_REGULAR_CHECK_CONTACT_REACHABILITY
  17, // 14 -> SYNC_PURPOSE_VISIBILITY_SELECTED_CONTACT_CHANGE
  0, // 15 -> SYNC_PURPOSE_ACCOUNT_CHANGE
  9, // 16 -> SYNC_PURPOSE_REGENERATE_CERTIFICATES
  5, // 17 -> SYNC_PURPOSE_DEVICE_CONTACTS_CONSENT_CHANGE
};

const std::string& SyncPurpose_Name(
    SyncPurpose value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          SyncPurpose_entries,
          SyncPurpose_entries_by_number,
          18, SyncPurpose_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      SyncPurpose_entries,
      SyncPurpose_entries_by_number,
      18, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     SyncPurpose_strings[idx].get();
}
bool SyncPurpose_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SyncPurpose* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      SyncPurpose_entries, 18, name, &int_value);
  if (success) {
    *value = static_cast<SyncPurpose>(int_value);
  }
  return success;
}
bool ClientRole_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ClientRole_strings[3] = {};

static const char ClientRole_names[] =
  "CLIENT_ROLE_RECEIVER"
  "CLIENT_ROLE_SENDER"
  "CLIENT_ROLE_UNKNOWN";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ClientRole_entries[] = {
  { {ClientRole_names + 0, 20}, 2 },
  { {ClientRole_names + 20, 18}, 1 },
  { {ClientRole_names + 38, 19}, 0 },
};

static const int ClientRole_entries_by_number[] = {
  2, // 0 -> CLIENT_ROLE_UNKNOWN
  1, // 1 -> CLIENT_ROLE_SENDER
  0, // 2 -> CLIENT_ROLE_RECEIVER
};

const std::string& ClientRole_Name(
    ClientRole value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          ClientRole_entries,
          ClientRole_entries_by_number,
          3, ClientRole_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      ClientRole_entries,
      ClientRole_entries_by_number,
      3, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     ClientRole_strings[idx].get();
}
bool ClientRole_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientRole* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      ClientRole_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<ClientRole>(int_value);
  }
  return success;
}
bool ScanType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}

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

static const char ScanType_names[] =
  "BACKGROUND_SCAN"
  "DIRECT_SHARE_SCAN"
  "FOREGROUND_RETRY_SCAN"
  "FOREGROUND_SCAN"
  "UNKNOWN_SCAN_TYPE";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ScanType_entries[] = {
  { {ScanType_names + 0, 15}, 4 },
  { {ScanType_names + 15, 17}, 3 },
  { {ScanType_names + 32, 21}, 2 },
  { {ScanType_names + 53, 15}, 1 },
  { {ScanType_names + 68, 17}, 0 },
};

static const int ScanType_entries_by_number[] = {
  4, // 0 -> UNKNOWN_SCAN_TYPE
  3, // 1 -> FOREGROUND_SCAN
  2, // 2 -> FOREGROUND_RETRY_SCAN
  1, // 3 -> DIRECT_SHARE_SCAN
  0, // 4 -> BACKGROUND_SCAN
};

const std::string& ScanType_Name(
    ScanType value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          ScanType_entries,
          ScanType_entries_by_number,
          5, ScanType_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      ScanType_entries,
      ScanType_entries_by_number,
      5, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     ScanType_strings[idx].get();
}
bool ScanType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ScanType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      ScanType_entries, 5, name, &int_value);
  if (success) {
    *value = static_cast<ScanType>(int_value);
  }
  return success;
}
bool ParsingFailedType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ParsingFailedType_strings[3] = {};

static const char ParsingFailedType_names[] =
  "FAILED_CONVERT_SHARE_TARGET"
  "FAILED_PARSE_ADVERTISEMENT"
  "FAILED_UNKNOWN_TYPE";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ParsingFailedType_entries[] = {
  { {ParsingFailedType_names + 0, 27}, 2 },
  { {ParsingFailedType_names + 27, 26}, 1 },
  { {ParsingFailedType_names + 53, 19}, 0 },
};

static const int ParsingFailedType_entries_by_number[] = {
  2, // 0 -> FAILED_UNKNOWN_TYPE
  1, // 1 -> FAILED_PARSE_ADVERTISEMENT
  0, // 2 -> FAILED_CONVERT_SHARE_TARGET
};

const std::string& ParsingFailedType_Name(
    ParsingFailedType value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          ParsingFailedType_entries,
          ParsingFailedType_entries_by_number,
          3, ParsingFailedType_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      ParsingFailedType_entries,
      ParsingFailedType_entries_by_number,
      3, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     ParsingFailedType_strings[idx].get();
}
bool ParsingFailedType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ParsingFailedType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      ParsingFailedType_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<ParsingFailedType>(int_value);
  }
  return success;
}
bool AdvertisingMode_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}

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

static const char AdvertisingMode_names[] =
  "BACKGROUND_ADVERTISING_MODE"
  "FOREGROUND_ADVERTISING_MODE"
  "MIDGROUND_ADVERTISING_MODE"
  "SCREEN_OFF_ADVERTISING_MODE"
  "UNKNOWN_ADVERTISING_MODE";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry AdvertisingMode_entries[] = {
  { {AdvertisingMode_names + 0, 27}, 2 },
  { {AdvertisingMode_names + 27, 27}, 4 },
  { {AdvertisingMode_names + 54, 26}, 3 },
  { {AdvertisingMode_names + 80, 27}, 1 },
  { {AdvertisingMode_names + 107, 24}, 0 },
};

static const int AdvertisingMode_entries_by_number[] = {
  4, // 0 -> UNKNOWN_ADVERTISING_MODE
  3, // 1 -> SCREEN_OFF_ADVERTISING_MODE
  0, // 2 -> BACKGROUND_ADVERTISING_MODE
  2, // 3 -> MIDGROUND_ADVERTISING_MODE
  1, // 4 -> FOREGROUND_ADVERTISING_MODE
};

const std::string& AdvertisingMode_Name(
    AdvertisingMode value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          AdvertisingMode_entries,
          AdvertisingMode_entries_by_number,
          5, AdvertisingMode_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      AdvertisingMode_entries,
      AdvertisingMode_entries_by_number,
      5, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     AdvertisingMode_strings[idx].get();
}
bool AdvertisingMode_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AdvertisingMode* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      AdvertisingMode_entries, 5, name, &int_value);
  if (success) {
    *value = static_cast<AdvertisingMode>(int_value);
  }
  return success;
}
bool DiscoveryMode_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}

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

static const char DiscoveryMode_names[] =
  "BACKGROUND_DISCOVERY_MODE"
  "FOREGROUND_DISCOVERY_MODE"
  "MIDGROUND_DISCOVERY_MODE"
  "SCREEN_OFF_DISCOVERY_MODE"
  "UNKNOWN_DISCOVERY_MODE";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry DiscoveryMode_entries[] = {
  { {DiscoveryMode_names + 0, 25}, 2 },
  { {DiscoveryMode_names + 25, 25}, 4 },
  { {DiscoveryMode_names + 50, 24}, 3 },
  { {DiscoveryMode_names + 74, 25}, 1 },
  { {DiscoveryMode_names + 99, 22}, 0 },
};

static const int DiscoveryMode_entries_by_number[] = {
  4, // 0 -> UNKNOWN_DISCOVERY_MODE
  3, // 1 -> SCREEN_OFF_DISCOVERY_MODE
  0, // 2 -> BACKGROUND_DISCOVERY_MODE
  2, // 3 -> MIDGROUND_DISCOVERY_MODE
  1, // 4 -> FOREGROUND_DISCOVERY_MODE
};

const std::string& DiscoveryMode_Name(
    DiscoveryMode value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          DiscoveryMode_entries,
          DiscoveryMode_entries_by_number,
          5, DiscoveryMode_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      DiscoveryMode_entries,
      DiscoveryMode_entries_by_number,
      5, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     DiscoveryMode_strings[idx].get();
}
bool DiscoveryMode_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DiscoveryMode* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      DiscoveryMode_entries, 5, name, &int_value);
  if (success) {
    *value = static_cast<DiscoveryMode>(int_value);
  }
  return success;
}
bool ActivityName_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:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ActivityName_strings[13] = {};

static const char ActivityName_names[] =
  "CONSENTS_ACTIVITY"
  "DEVICE_VISIBILITY_ACTIVITY"
  "QUICK_SETTINGS_ACTIVITY"
  "RECEIVE_SURFACE_ACTIVITY"
  "REMOTE_COPY_SHARE_SHEET_ACTIVITY"
  "SETTINGS_ACTIVITY"
  "SETTINGS_REVIEW_ACTIVITY"
  "SETUP_ACTIVITY"
  "SETUP_WIZARD_ACTIVITY"
  "SET_DATA_USAGE_DIALOG"
  "SET_DEVICE_NAME_DIALOG"
  "SHARE_SHEET_ACTIVITY"
  "UNKNOWN_ACTIVITY";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ActivityName_entries[] = {
  { {ActivityName_names + 0, 17}, 6 },
  { {ActivityName_names + 17, 26}, 5 },
  { {ActivityName_names + 43, 23}, 9 },
  { {ActivityName_names + 66, 24}, 3 },
  { {ActivityName_names + 90, 32}, 10 },
  { {ActivityName_names + 122, 17}, 2 },
  { {ActivityName_names + 139, 24}, 12 },
  { {ActivityName_names + 163, 14}, 4 },
  { {ActivityName_names + 177, 21}, 11 },
  { {ActivityName_names + 198, 21}, 8 },
  { {ActivityName_names + 219, 22}, 7 },
  { {ActivityName_names + 241, 20}, 1 },
  { {ActivityName_names + 261, 16}, 0 },
};

static const int ActivityName_entries_by_number[] = {
  12, // 0 -> UNKNOWN_ACTIVITY
  11, // 1 -> SHARE_SHEET_ACTIVITY
  5, // 2 -> SETTINGS_ACTIVITY
  3, // 3 -> RECEIVE_SURFACE_ACTIVITY
  7, // 4 -> SETUP_ACTIVITY
  1, // 5 -> DEVICE_VISIBILITY_ACTIVITY
  0, // 6 -> CONSENTS_ACTIVITY
  10, // 7 -> SET_DEVICE_NAME_DIALOG
  9, // 8 -> SET_DATA_USAGE_DIALOG
  2, // 9 -> QUICK_SETTINGS_ACTIVITY
  4, // 10 -> REMOTE_COPY_SHARE_SHEET_ACTIVITY
  8, // 11 -> SETUP_WIZARD_ACTIVITY
  6, // 12 -> SETTINGS_REVIEW_ACTIVITY
};

const std::string& ActivityName_Name(
    ActivityName value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          ActivityName_entries,
          ActivityName_entries_by_number,
          13, ActivityName_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      ActivityName_entries,
      ActivityName_entries_by_number,
      13, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     ActivityName_strings[idx].get();
}
bool ActivityName_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ActivityName* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      ActivityName_entries, 13, name, &int_value);
  if (success) {
    *value = static_cast<ActivityName>(int_value);
  }
  return success;
}
bool ConsentType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ConsentType_strings[3] = {};

static const char ConsentType_names[] =
  "CONSENT_TYPE_C11N"
  "CONSENT_TYPE_DEVICE_CONTACT"
  "CONSENT_TYPE_UNKNOWN";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ConsentType_entries[] = {
  { {ConsentType_names + 0, 17}, 1 },
  { {ConsentType_names + 17, 27}, 2 },
  { {ConsentType_names + 44, 20}, 0 },
};

static const int ConsentType_entries_by_number[] = {
  2, // 0 -> CONSENT_TYPE_UNKNOWN
  0, // 1 -> CONSENT_TYPE_C11N
  1, // 2 -> CONSENT_TYPE_DEVICE_CONTACT
};

const std::string& ConsentType_Name(
    ConsentType value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          ConsentType_entries,
          ConsentType_entries_by_number,
          3, ConsentType_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      ConsentType_entries,
      ConsentType_entries_by_number,
      3, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     ConsentType_strings[idx].get();
}
bool ConsentType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConsentType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      ConsentType_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<ConsentType>(int_value);
  }
  return success;
}
bool ConsentAcceptanceStatus_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

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

static const char ConsentAcceptanceStatus_names[] =
  "CONSENT_ACCEPTED"
  "CONSENT_DECLINED"
  "CONSENT_UNABLE_TO_ENABLE"
  "CONSENT_UNKNOWN_ACCEPT_STATUS";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ConsentAcceptanceStatus_entries[] = {
  { {ConsentAcceptanceStatus_names + 0, 16}, 1 },
  { {ConsentAcceptanceStatus_names + 16, 16}, 2 },
  { {ConsentAcceptanceStatus_names + 32, 24}, 3 },
  { {ConsentAcceptanceStatus_names + 56, 29}, 0 },
};

static const int ConsentAcceptanceStatus_entries_by_number[] = {
  3, // 0 -> CONSENT_UNKNOWN_ACCEPT_STATUS
  0, // 1 -> CONSENT_ACCEPTED
  1, // 2 -> CONSENT_DECLINED
  2, // 3 -> CONSENT_UNABLE_TO_ENABLE
};

const std::string& ConsentAcceptanceStatus_Name(
    ConsentAcceptanceStatus value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          ConsentAcceptanceStatus_entries,
          ConsentAcceptanceStatus_entries_by_number,
          4, ConsentAcceptanceStatus_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      ConsentAcceptanceStatus_entries,
      ConsentAcceptanceStatus_entries_by_number,
      4, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     ConsentAcceptanceStatus_strings[idx].get();
}
bool ConsentAcceptanceStatus_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConsentAcceptanceStatus* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      ConsentAcceptanceStatus_entries, 4, name, &int_value);
  if (success) {
    *value = static_cast<ConsentAcceptanceStatus>(int_value);
  }
  return success;
}
bool ApkSource_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ApkSource_strings[3] = {};

static const char ApkSource_names[] =
  "APK_FROM_SD_CARD"
  "INSTALLED_APP"
  "UNKNOWN_APK_SOURCE";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ApkSource_entries[] = {
  { {ApkSource_names + 0, 16}, 1 },
  { {ApkSource_names + 16, 13}, 2 },
  { {ApkSource_names + 29, 18}, 0 },
};

static const int ApkSource_entries_by_number[] = {
  2, // 0 -> UNKNOWN_APK_SOURCE
  0, // 1 -> APK_FROM_SD_CARD
  1, // 2 -> INSTALLED_APP
};

const std::string& ApkSource_Name(
    ApkSource value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          ApkSource_entries,
          ApkSource_entries_by_number,
          3, ApkSource_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      ApkSource_entries,
      ApkSource_entries_by_number,
      3, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     ApkSource_strings[idx].get();
}
bool ApkSource_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ApkSource* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      ApkSource_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<ApkSource>(int_value);
  }
  return success;
}
bool InstallAPKStatus_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> InstallAPKStatus_strings[3] = {};

static const char InstallAPKStatus_names[] =
  "FAIL_INSTALLATION"
  "SUCCESS_INSTALLATION"
  "UNKNOWN_INSTALL_APK_STATUS";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry InstallAPKStatus_entries[] = {
  { {InstallAPKStatus_names + 0, 17}, 1 },
  { {InstallAPKStatus_names + 17, 20}, 2 },
  { {InstallAPKStatus_names + 37, 26}, 0 },
};

static const int InstallAPKStatus_entries_by_number[] = {
  2, // 0 -> UNKNOWN_INSTALL_APK_STATUS
  0, // 1 -> FAIL_INSTALLATION
  1, // 2 -> SUCCESS_INSTALLATION
};

const std::string& InstallAPKStatus_Name(
    InstallAPKStatus value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          InstallAPKStatus_entries,
          InstallAPKStatus_entries_by_number,
          3, InstallAPKStatus_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      InstallAPKStatus_entries,
      InstallAPKStatus_entries_by_number,
      3, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     InstallAPKStatus_strings[idx].get();
}
bool InstallAPKStatus_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, InstallAPKStatus* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      InstallAPKStatus_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<InstallAPKStatus>(int_value);
  }
  return success;
}
bool VerifyAPKStatus_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

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

static const char VerifyAPKStatus_names[] =
  "ALREADY_INSTALLED"
  "INSTALLABLE"
  "NOT_INSTALLABLE"
  "UNKNOWN_VERIFY_APK_STATUS";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry VerifyAPKStatus_entries[] = {
  { {VerifyAPKStatus_names + 0, 17}, 3 },
  { {VerifyAPKStatus_names + 17, 11}, 2 },
  { {VerifyAPKStatus_names + 28, 15}, 1 },
  { {VerifyAPKStatus_names + 43, 25}, 0 },
};

static const int VerifyAPKStatus_entries_by_number[] = {
  3, // 0 -> UNKNOWN_VERIFY_APK_STATUS
  2, // 1 -> NOT_INSTALLABLE
  1, // 2 -> INSTALLABLE
  0, // 3 -> ALREADY_INSTALLED
};

const std::string& VerifyAPKStatus_Name(
    VerifyAPKStatus value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          VerifyAPKStatus_entries,
          VerifyAPKStatus_entries_by_number,
          4, VerifyAPKStatus_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      VerifyAPKStatus_entries,
      VerifyAPKStatus_entries_by_number,
      4, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     VerifyAPKStatus_strings[idx].get();
}
bool VerifyAPKStatus_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, VerifyAPKStatus* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      VerifyAPKStatus_entries, 4, name, &int_value);
  if (success) {
    *value = static_cast<VerifyAPKStatus>(int_value);
  }
  return success;
}
bool ShowNotificationStatus_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ShowNotificationStatus_strings[3] = {};

static const char ShowNotificationStatus_names[] =
  "NOT_SHOW"
  "SHOW"
  "UNKNOWN_SHOW_NOTIFICATION_STATUS";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ShowNotificationStatus_entries[] = {
  { {ShowNotificationStatus_names + 0, 8}, 2 },
  { {ShowNotificationStatus_names + 8, 4}, 1 },
  { {ShowNotificationStatus_names + 12, 32}, 0 },
};

static const int ShowNotificationStatus_entries_by_number[] = {
  2, // 0 -> UNKNOWN_SHOW_NOTIFICATION_STATUS
  1, // 1 -> SHOW
  0, // 2 -> NOT_SHOW
};

const std::string& ShowNotificationStatus_Name(
    ShowNotificationStatus value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          ShowNotificationStatus_entries,
          ShowNotificationStatus_entries_by_number,
          3, ShowNotificationStatus_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      ShowNotificationStatus_entries,
      ShowNotificationStatus_entries_by_number,
      3, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     ShowNotificationStatus_strings[idx].get();
}
bool ShowNotificationStatus_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ShowNotificationStatus* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      ShowNotificationStatus_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<ShowNotificationStatus>(int_value);
  }
  return success;
}
bool PermissionRequestResult_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

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

static const char PermissionRequestResult_names[] =
  "PERMISSION_GRANTED"
  "PERMISSION_REJECTED"
  "PERMISSION_UNABLE_TO_GRANT"
  "PERMISSION_UNKNOWN_REQUEST_RESULT";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry PermissionRequestResult_entries[] = {
  { {PermissionRequestResult_names + 0, 18}, 1 },
  { {PermissionRequestResult_names + 18, 19}, 2 },
  { {PermissionRequestResult_names + 37, 26}, 3 },
  { {PermissionRequestResult_names + 63, 33}, 0 },
};

static const int PermissionRequestResult_entries_by_number[] = {
  3, // 0 -> PERMISSION_UNKNOWN_REQUEST_RESULT
  0, // 1 -> PERMISSION_GRANTED
  1, // 2 -> PERMISSION_REJECTED
  2, // 3 -> PERMISSION_UNABLE_TO_GRANT
};

const std::string& PermissionRequestResult_Name(
    PermissionRequestResult value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          PermissionRequestResult_entries,
          PermissionRequestResult_entries_by_number,
          4, PermissionRequestResult_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      PermissionRequestResult_entries,
      PermissionRequestResult_entries_by_number,
      4, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     PermissionRequestResult_strings[idx].get();
}
bool PermissionRequestResult_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PermissionRequestResult* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      PermissionRequestResult_entries, 4, name, &int_value);
  if (success) {
    *value = static_cast<PermissionRequestResult>(int_value);
  }
  return success;
}
bool PermissionRequestType_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> PermissionRequestType_strings[6] = {};

static const char PermissionRequestType_names[] =
  "PERMISSION_AIRPLANE_MODE_OFF"
  "PERMISSION_BLUETOOTH"
  "PERMISSION_LOCATION"
  "PERMISSION_UNKNOWN_TYPE"
  "PERMISSION_WIFI"
  "PERMISSION_WIFI_HOTSPOT";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry PermissionRequestType_entries[] = {
  { {PermissionRequestType_names + 0, 28}, 1 },
  { {PermissionRequestType_names + 28, 20}, 3 },
  { {PermissionRequestType_names + 48, 19}, 4 },
  { {PermissionRequestType_names + 67, 23}, 0 },
  { {PermissionRequestType_names + 90, 15}, 2 },
  { {PermissionRequestType_names + 105, 23}, 5 },
};

static const int PermissionRequestType_entries_by_number[] = {
  3, // 0 -> PERMISSION_UNKNOWN_TYPE
  0, // 1 -> PERMISSION_AIRPLANE_MODE_OFF
  4, // 2 -> PERMISSION_WIFI
  1, // 3 -> PERMISSION_BLUETOOTH
  2, // 4 -> PERMISSION_LOCATION
  5, // 5 -> PERMISSION_WIFI_HOTSPOT
};

const std::string& PermissionRequestType_Name(
    PermissionRequestType value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          PermissionRequestType_entries,
          PermissionRequestType_entries_by_number,
          6, PermissionRequestType_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      PermissionRequestType_entries,
      PermissionRequestType_entries_by_number,
      6, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     PermissionRequestType_strings[idx].get();
}
bool PermissionRequestType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PermissionRequestType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      PermissionRequestType_entries, 6, name, &int_value);
  if (success) {
    *value = static_cast<PermissionRequestType>(int_value);
  }
  return success;
}
bool SharingUseCase_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> SharingUseCase_strings[9] = {};

static const char SharingUseCase_names[] =
  "USE_CASE_APP_SHARE"
  "USE_CASE_NEARBY_SHARE"
  "USE_CASE_NEARBY_SHARE_WITH_QR_CODE"
  "USE_CASE_QUICK_SETTING_FILE_SHARE"
  "USE_CASE_REDIRECTED_FROM_BLUETOOTH_SHARE"
  "USE_CASE_REMOTE_COPY_PASTE"
  "USE_CASE_SETUP_WIZARD"
  "USE_CASE_UNKNOWN"
  "USE_CASE_WIFI_CREDENTIAL";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry SharingUseCase_entries[] = {
  { {SharingUseCase_names + 0, 18}, 4 },
  { {SharingUseCase_names + 18, 21}, 1 },
  { {SharingUseCase_names + 39, 34}, 7 },
  { {SharingUseCase_names + 73, 33}, 5 },
  { {SharingUseCase_names + 106, 40}, 8 },
  { {SharingUseCase_names + 146, 26}, 2 },
  { {SharingUseCase_names + 172, 21}, 6 },
  { {SharingUseCase_names + 193, 16}, 0 },
  { {SharingUseCase_names + 209, 24}, 3 },
};

static const int SharingUseCase_entries_by_number[] = {
  7, // 0 -> USE_CASE_UNKNOWN
  1, // 1 -> USE_CASE_NEARBY_SHARE
  5, // 2 -> USE_CASE_REMOTE_COPY_PASTE
  8, // 3 -> USE_CASE_WIFI_CREDENTIAL
  0, // 4 -> USE_CASE_APP_SHARE
  3, // 5 -> USE_CASE_QUICK_SETTING_FILE_SHARE
  6, // 6 -> USE_CASE_SETUP_WIZARD
  2, // 7 -> USE_CASE_NEARBY_SHARE_WITH_QR_CODE
  4, // 8 -> USE_CASE_REDIRECTED_FROM_BLUETOOTH_SHARE
};

const std::string& SharingUseCase_Name(
    SharingUseCase value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          SharingUseCase_entries,
          SharingUseCase_entries_by_number,
          9, SharingUseCase_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      SharingUseCase_entries,
      SharingUseCase_entries_by_number,
      9, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     SharingUseCase_strings[idx].get();
}
bool SharingUseCase_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SharingUseCase* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      SharingUseCase_entries, 9, name, &int_value);
  if (success) {
    *value = static_cast<SharingUseCase>(int_value);
  }
  return success;
}
bool AppCrashReason_IsValid(int value) {
  switch (value) {
    case 0:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> AppCrashReason_strings[1] = {};

static const char AppCrashReason_names[] =
  "APP_CRASH_REASON_UNKNOWN";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry AppCrashReason_entries[] = {
  { {AppCrashReason_names + 0, 24}, 0 },
};

static const int AppCrashReason_entries_by_number[] = {
  0, // 0 -> APP_CRASH_REASON_UNKNOWN
};

const std::string& AppCrashReason_Name(
    AppCrashReason value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          AppCrashReason_entries,
          AppCrashReason_entries_by_number,
          1, AppCrashReason_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      AppCrashReason_entries,
      AppCrashReason_entries_by_number,
      1, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     AppCrashReason_strings[idx].get();
}
bool AppCrashReason_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AppCrashReason* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      AppCrashReason_entries, 1, name, &int_value);
  if (success) {
    *value = static_cast<AppCrashReason>(int_value);
  }
  return success;
}
bool AttachmentSourceType_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> AttachmentSourceType_strings[7] = {};

static const char AttachmentSourceType_names[] =
  "ATTACHMENT_SOURCE_CONTEXT_MENU"
  "ATTACHMENT_SOURCE_DRAG_AND_DROP"
  "ATTACHMENT_SOURCE_PASTE"
  "ATTACHMENT_SOURCE_SELECT_FILES_BUTTON"
  "ATTACHMENT_SOURCE_SELECT_FOLDERS_BUTTON"
  "ATTACHMENT_SOURCE_SHARE_ACTIVATION"
  "ATTACHMENT_SOURCE_UNKNOWN";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry AttachmentSourceType_entries[] = {
  { {AttachmentSourceType_names + 0, 30}, 1 },
  { {AttachmentSourceType_names + 30, 31}, 2 },
  { {AttachmentSourceType_names + 61, 23}, 4 },
  { {AttachmentSourceType_names + 84, 37}, 3 },
  { {AttachmentSourceType_names + 121, 39}, 5 },
  { {AttachmentSourceType_names + 160, 34}, 6 },
  { {AttachmentSourceType_names + 194, 25}, 0 },
};

static const int AttachmentSourceType_entries_by_number[] = {
  6, // 0 -> ATTACHMENT_SOURCE_UNKNOWN
  0, // 1 -> ATTACHMENT_SOURCE_CONTEXT_MENU
  1, // 2 -> ATTACHMENT_SOURCE_DRAG_AND_DROP
  3, // 3 -> ATTACHMENT_SOURCE_SELECT_FILES_BUTTON
  2, // 4 -> ATTACHMENT_SOURCE_PASTE
  4, // 5 -> ATTACHMENT_SOURCE_SELECT_FOLDERS_BUTTON
  5, // 6 -> ATTACHMENT_SOURCE_SHARE_ACTIVATION
};

const std::string& AttachmentSourceType_Name(
    AttachmentSourceType value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          AttachmentSourceType_entries,
          AttachmentSourceType_entries_by_number,
          7, AttachmentSourceType_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      AttachmentSourceType_entries,
      AttachmentSourceType_entries_by_number,
      7, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     AttachmentSourceType_strings[idx].get();
}
bool AttachmentSourceType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AttachmentSourceType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      AttachmentSourceType_entries, 7, name, &int_value);
  if (success) {
    *value = static_cast<AttachmentSourceType>(int_value);
  }
  return success;
}
bool PreferencesAction_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:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> PreferencesAction_strings[12] = {};

static const char PreferencesAction_names[] =
  "PREFERENCES_ACTION_ATTEMPT_LOAD"
  "PREFERENCES_ACTION_CHECK_IF_PREFERENCES_BACKUP_FILE_EXISTS"
  "PREFERENCES_ACTION_CHECK_IF_PREFERENCES_FILE_IS_CORRUPTED"
  "PREFERENCES_ACTION_CHECK_IF_PREFERENCES_INPUT_STREAM_STATUS"
  "PREFERENCES_ACTION_CHECK_IF_PREFERENCES_PATH_EXISTS"
  "PREFERENCES_ACTION_CREATE_PREFERENCES_PATH"
  "PREFERENCES_ACTION_LOAD_PREFERENCES"
  "PREFERENCES_ACTION_MAKE_PREFERENCES_BACKUP_FILE"
  "PREFERENCES_ACTION_NO_ACTION"
  "PREFERENCES_ACTION_RESTORE_FROM_BACKUP"
  "PREFERENCES_ACTION_SAVE_PREFERENCESS"
  "PREFERENCES_ACTION_UNKNOWN";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry PreferencesAction_entries[] = {
  { {PreferencesAction_names + 0, 31}, 4 },
  { {PreferencesAction_names + 31, 58}, 11 },
  { {PreferencesAction_names + 89, 57}, 10 },
  { {PreferencesAction_names + 146, 59}, 9 },
  { {PreferencesAction_names + 205, 51}, 8 },
  { {PreferencesAction_names + 256, 42}, 6 },
  { {PreferencesAction_names + 298, 35}, 2 },
  { {PreferencesAction_names + 333, 47}, 7 },
  { {PreferencesAction_names + 380, 28}, 1 },
  { {PreferencesAction_names + 408, 38}, 5 },
  { {PreferencesAction_names + 446, 36}, 3 },
  { {PreferencesAction_names + 482, 26}, 0 },
};

static const int PreferencesAction_entries_by_number[] = {
  11, // 0 -> PREFERENCES_ACTION_UNKNOWN
  8, // 1 -> PREFERENCES_ACTION_NO_ACTION
  6, // 2 -> PREFERENCES_ACTION_LOAD_PREFERENCES
  10, // 3 -> PREFERENCES_ACTION_SAVE_PREFERENCESS
  0, // 4 -> PREFERENCES_ACTION_ATTEMPT_LOAD
  9, // 5 -> PREFERENCES_ACTION_RESTORE_FROM_BACKUP
  5, // 6 -> PREFERENCES_ACTION_CREATE_PREFERENCES_PATH
  7, // 7 -> PREFERENCES_ACTION_MAKE_PREFERENCES_BACKUP_FILE
  4, // 8 -> PREFERENCES_ACTION_CHECK_IF_PREFERENCES_PATH_EXISTS
  3, // 9 -> PREFERENCES_ACTION_CHECK_IF_PREFERENCES_INPUT_STREAM_STATUS
  2, // 10 -> PREFERENCES_ACTION_CHECK_IF_PREFERENCES_FILE_IS_CORRUPTED
  1, // 11 -> PREFERENCES_ACTION_CHECK_IF_PREFERENCES_BACKUP_FILE_EXISTS
};

const std::string& PreferencesAction_Name(
    PreferencesAction value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          PreferencesAction_entries,
          PreferencesAction_entries_by_number,
          12, PreferencesAction_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      PreferencesAction_entries,
      PreferencesAction_entries_by_number,
      12, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     PreferencesAction_strings[idx].get();
}
bool PreferencesAction_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PreferencesAction* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      PreferencesAction_entries, 12, name, &int_value);
  if (success) {
    *value = static_cast<PreferencesAction>(int_value);
  }
  return success;
}
bool PreferencesActionStatus_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> PreferencesActionStatus_strings[3] = {};

static const char PreferencesActionStatus_names[] =
  "PREFERENCES_ACTION_STATUS_FAIL"
  "PREFERENCES_ACTION_STATUS_SUCCESS"
  "PREFERENCES_ACTION_STATUS_UNKNOWN";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry PreferencesActionStatus_entries[] = {
  { {PreferencesActionStatus_names + 0, 30}, 2 },
  { {PreferencesActionStatus_names + 30, 33}, 1 },
  { {PreferencesActionStatus_names + 63, 33}, 0 },
};

static const int PreferencesActionStatus_entries_by_number[] = {
  2, // 0 -> PREFERENCES_ACTION_STATUS_UNKNOWN
  1, // 1 -> PREFERENCES_ACTION_STATUS_SUCCESS
  0, // 2 -> PREFERENCES_ACTION_STATUS_FAIL
};

const std::string& PreferencesActionStatus_Name(
    PreferencesActionStatus value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          PreferencesActionStatus_entries,
          PreferencesActionStatus_entries_by_number,
          3, PreferencesActionStatus_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      PreferencesActionStatus_entries,
      PreferencesActionStatus_entries_by_number,
      3, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     PreferencesActionStatus_strings[idx].get();
}
bool PreferencesActionStatus_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PreferencesActionStatus* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      PreferencesActionStatus_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<PreferencesActionStatus>(int_value);
  }
  return success;
}
bool FastInitState_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

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

static const char FastInitState_names[] =
  "FAST_INIT_CLOSE_STATE"
  "FAST_INIT_FAR_STATE"
  "FAST_INIT_LOST_STATE"
  "FAST_INIT_UNKNOWN_STATE";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry FastInitState_entries[] = {
  { {FastInitState_names + 0, 21}, 1 },
  { {FastInitState_names + 21, 19}, 2 },
  { {FastInitState_names + 40, 20}, 3 },
  { {FastInitState_names + 60, 23}, 0 },
};

static const int FastInitState_entries_by_number[] = {
  3, // 0 -> FAST_INIT_UNKNOWN_STATE
  0, // 1 -> FAST_INIT_CLOSE_STATE
  1, // 2 -> FAST_INIT_FAR_STATE
  2, // 3 -> FAST_INIT_LOST_STATE
};

const std::string& FastInitState_Name(
    FastInitState value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          FastInitState_entries,
          FastInitState_entries_by_number,
          4, FastInitState_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      FastInitState_entries,
      FastInitState_entries_by_number,
      4, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     FastInitState_strings[idx].get();
}
bool FastInitState_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FastInitState* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      FastInitState_entries, 4, name, &int_value);
  if (success) {
    *value = static_cast<FastInitState>(int_value);
  }
  return success;
}
bool FastInitType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> FastInitType_strings[3] = {};

static const char FastInitType_names[] =
  "FAST_INIT_NOTIFY_TYPE"
  "FAST_INIT_SILENT_TYPE"
  "FAST_INIT_UNKNOWN_TYPE";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry FastInitType_entries[] = {
  { {FastInitType_names + 0, 21}, 1 },
  { {FastInitType_names + 21, 21}, 2 },
  { {FastInitType_names + 42, 22}, 0 },
};

static const int FastInitType_entries_by_number[] = {
  2, // 0 -> FAST_INIT_UNKNOWN_TYPE
  0, // 1 -> FAST_INIT_NOTIFY_TYPE
  1, // 2 -> FAST_INIT_SILENT_TYPE
};

const std::string& FastInitType_Name(
    FastInitType value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          FastInitType_entries,
          FastInitType_entries_by_number,
          3, FastInitType_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      FastInitType_entries,
      FastInitType_entries_by_number,
      3, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     FastInitType_strings[idx].get();
}
bool FastInitType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FastInitType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      FastInitType_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<FastInitType>(int_value);
  }
  return success;
}
bool DesktopNotification_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> DesktopNotification_strings[6] = {};

static const char DesktopNotification_names[] =
  "DESKTOP_NOTIFICATION_ACCEPT"
  "DESKTOP_NOTIFICATION_CONNECTING"
  "DESKTOP_NOTIFICATION_ERROR"
  "DESKTOP_NOTIFICATION_PROGRESS"
  "DESKTOP_NOTIFICATION_RECEIVED"
  "DESKTOP_NOTIFICATION_UNKNOWN";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry DesktopNotification_entries[] = {
  { {DesktopNotification_names + 0, 27}, 3 },
  { {DesktopNotification_names + 27, 31}, 1 },
  { {DesktopNotification_names + 58, 26}, 5 },
  { {DesktopNotification_names + 84, 29}, 2 },
  { {DesktopNotification_names + 113, 29}, 4 },
  { {DesktopNotification_names + 142, 28}, 0 },
};

static const int DesktopNotification_entries_by_number[] = {
  5, // 0 -> DESKTOP_NOTIFICATION_UNKNOWN
  1, // 1 -> DESKTOP_NOTIFICATION_CONNECTING
  3, // 2 -> DESKTOP_NOTIFICATION_PROGRESS
  0, // 3 -> DESKTOP_NOTIFICATION_ACCEPT
  4, // 4 -> DESKTOP_NOTIFICATION_RECEIVED
  2, // 5 -> DESKTOP_NOTIFICATION_ERROR
};

const std::string& DesktopNotification_Name(
    DesktopNotification value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          DesktopNotification_entries,
          DesktopNotification_entries_by_number,
          6, DesktopNotification_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      DesktopNotification_entries,
      DesktopNotification_entries_by_number,
      6, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     DesktopNotification_strings[idx].get();
}
bool DesktopNotification_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DesktopNotification* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      DesktopNotification_entries, 6, name, &int_value);
  if (success) {
    *value = static_cast<DesktopNotification>(int_value);
  }
  return success;
}
bool DesktopTransferEventType_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:
      return true;
    default:
      return false;
  }
}

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

static const char DesktopTransferEventType_names[] =
  "DESKTOP_TRANSFER_EVENT_RECEIVE_TYPE_ACCEPT"
  "DESKTOP_TRANSFER_EVENT_RECEIVE_TYPE_ERROR"
  "DESKTOP_TRANSFER_EVENT_RECEIVE_TYPE_PROGRESS"
  "DESKTOP_TRANSFER_EVENT_RECEIVE_TYPE_RECEIVED"
  "DESKTOP_TRANSFER_EVENT_SEND_TYPE_ERROR"
  "DESKTOP_TRANSFER_EVENT_SEND_TYPE_PROGRESS"
  "DESKTOP_TRANSFER_EVENT_SEND_TYPE_SELECT_A_DEVICE"
  "DESKTOP_TRANSFER_EVENT_SEND_TYPE_SENT"
  "DESKTOP_TRANSFER_EVENT_SEND_TYPE_START"
  "DESKTOP_TRANSFER_EVENT_TYPE_UNKNOWN";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry DesktopTransferEventType_entries[] = {
  { {DesktopTransferEventType_names + 0, 42}, 1 },
  { {DesktopTransferEventType_names + 42, 41}, 4 },
  { {DesktopTransferEventType_names + 83, 44}, 2 },
  { {DesktopTransferEventType_names + 127, 44}, 3 },
  { {DesktopTransferEventType_names + 171, 38}, 9 },
  { {DesktopTransferEventType_names + 209, 41}, 7 },
  { {DesktopTransferEventType_names + 250, 48}, 6 },
  { {DesktopTransferEventType_names + 298, 37}, 8 },
  { {DesktopTransferEventType_names + 335, 38}, 5 },
  { {DesktopTransferEventType_names + 373, 35}, 0 },
};

static const int DesktopTransferEventType_entries_by_number[] = {
  9, // 0 -> DESKTOP_TRANSFER_EVENT_TYPE_UNKNOWN
  0, // 1 -> DESKTOP_TRANSFER_EVENT_RECEIVE_TYPE_ACCEPT
  2, // 2 -> DESKTOP_TRANSFER_EVENT_RECEIVE_TYPE_PROGRESS
  3, // 3 -> DESKTOP_TRANSFER_EVENT_RECEIVE_TYPE_RECEIVED
  1, // 4 -> DESKTOP_TRANSFER_EVENT_RECEIVE_TYPE_ERROR
  8, // 5 -> DESKTOP_TRANSFER_EVENT_SEND_TYPE_START
  6, // 6 -> DESKTOP_TRANSFER_EVENT_SEND_TYPE_SELECT_A_DEVICE
  5, // 7 -> DESKTOP_TRANSFER_EVENT_SEND_TYPE_PROGRESS
  7, // 8 -> DESKTOP_TRANSFER_EVENT_SEND_TYPE_SENT
  4, // 9 -> DESKTOP_TRANSFER_EVENT_SEND_TYPE_ERROR
};

const std::string& DesktopTransferEventType_Name(
    DesktopTransferEventType value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          DesktopTransferEventType_entries,
          DesktopTransferEventType_entries_by_number,
          10, DesktopTransferEventType_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      DesktopTransferEventType_entries,
      DesktopTransferEventType_entries_by_number,
      10, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     DesktopTransferEventType_strings[idx].get();
}
bool DesktopTransferEventType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DesktopTransferEventType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      DesktopTransferEventType_entries, 10, name, &int_value);
  if (success) {
    *value = static_cast<DesktopTransferEventType>(int_value);
  }
  return success;
}
bool DecryptCertificateFailureStatus_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> DecryptCertificateFailureStatus_strings[7] = {};

static const char DecryptCertificateFailureStatus_names[] =
  "DECRYPT_CERT_BAD_PADDING_FAILURE"
  "DECRYPT_CERT_ILLEGAL_BLOCK_SIZE_FAILURE"
  "DECRYPT_CERT_INVALID_ALGORITHM_PARAMETER_FAILURE"
  "DECRYPT_CERT_INVALID_KEY_FAILURE"
  "DECRYPT_CERT_NO_SUCH_ALGORITHM_FAILURE"
  "DECRYPT_CERT_NO_SUCH_PADDING_FAILURE"
  "DECRYPT_CERT_UNKNOWN_FAILURE";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry DecryptCertificateFailureStatus_entries[] = {
  { {DecryptCertificateFailureStatus_names + 0, 32}, 6 },
  { {DecryptCertificateFailureStatus_names + 32, 39}, 5 },
  { {DecryptCertificateFailureStatus_names + 71, 48}, 4 },
  { {DecryptCertificateFailureStatus_names + 119, 32}, 3 },
  { {DecryptCertificateFailureStatus_names + 151, 38}, 1 },
  { {DecryptCertificateFailureStatus_names + 189, 36}, 2 },
  { {DecryptCertificateFailureStatus_names + 225, 28}, 0 },
};

static const int DecryptCertificateFailureStatus_entries_by_number[] = {
  6, // 0 -> DECRYPT_CERT_UNKNOWN_FAILURE
  4, // 1 -> DECRYPT_CERT_NO_SUCH_ALGORITHM_FAILURE
  5, // 2 -> DECRYPT_CERT_NO_SUCH_PADDING_FAILURE
  3, // 3 -> DECRYPT_CERT_INVALID_KEY_FAILURE
  2, // 4 -> DECRYPT_CERT_INVALID_ALGORITHM_PARAMETER_FAILURE
  1, // 5 -> DECRYPT_CERT_ILLEGAL_BLOCK_SIZE_FAILURE
  0, // 6 -> DECRYPT_CERT_BAD_PADDING_FAILURE
};

const std::string& DecryptCertificateFailureStatus_Name(
    DecryptCertificateFailureStatus value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          DecryptCertificateFailureStatus_entries,
          DecryptCertificateFailureStatus_entries_by_number,
          7, DecryptCertificateFailureStatus_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      DecryptCertificateFailureStatus_entries,
      DecryptCertificateFailureStatus_entries_by_number,
      7, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     DecryptCertificateFailureStatus_strings[idx].get();
}
bool DecryptCertificateFailureStatus_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DecryptCertificateFailureStatus* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      DecryptCertificateFailureStatus_entries, 7, name, &int_value);
  if (success) {
    *value = static_cast<DecryptCertificateFailureStatus>(int_value);
  }
  return success;
}
bool ContactAccess_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}

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

static const char ContactAccess_names[] =
  "CONTACT_ACCESS_NO_CONTACT_UPLOADED"
  "CONTACT_ACCESS_ONLY_UPLOAD_GOOGLE_CONTACT"
  "CONTACT_ACCESS_UNKNOWN"
  "CONTACT_ACCESS_UPLOAD_CONTACT_FOR_DEVICE_CONTACT_CONSENT"
  "CONTACT_ACCESS_UPLOAD_CONTACT_FOR_QUICK_SHARE_CONSENT";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ContactAccess_entries[] = {
  { {ContactAccess_names + 0, 34}, 1 },
  { {ContactAccess_names + 34, 41}, 2 },
  { {ContactAccess_names + 75, 22}, 0 },
  { {ContactAccess_names + 97, 56}, 3 },
  { {ContactAccess_names + 153, 53}, 4 },
};

static const int ContactAccess_entries_by_number[] = {
  2, // 0 -> CONTACT_ACCESS_UNKNOWN
  0, // 1 -> CONTACT_ACCESS_NO_CONTACT_UPLOADED
  1, // 2 -> CONTACT_ACCESS_ONLY_UPLOAD_GOOGLE_CONTACT
  3, // 3 -> CONTACT_ACCESS_UPLOAD_CONTACT_FOR_DEVICE_CONTACT_CONSENT
  4, // 4 -> CONTACT_ACCESS_UPLOAD_CONTACT_FOR_QUICK_SHARE_CONSENT
};

const std::string& ContactAccess_Name(
    ContactAccess value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          ContactAccess_entries,
          ContactAccess_entries_by_number,
          5, ContactAccess_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      ContactAccess_entries,
      ContactAccess_entries_by_number,
      5, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     ContactAccess_strings[idx].get();
}
bool ContactAccess_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ContactAccess* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      ContactAccess_entries, 5, name, &int_value);
  if (success) {
    *value = static_cast<ContactAccess>(int_value);
  }
  return success;
}
bool IdentityVerification_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

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

static const char IdentityVerification_names[] =
  "IDENTITY_VERIFICATION_NO_PHONE_NUMBER_VERIFIED"
  "IDENTITY_VERIFICATION_PHONE_NUMBER_VERIFIED_LINKED_TO_QS_GAIA"
  "IDENTITY_VERIFICATION_PHONE_NUMBER_VERIFIED_NOT_LINKED_TO_GAIA"
  "IDENTITY_VERIFICATION_UNKNOWN";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry IdentityVerification_entries[] = {
  { {IdentityVerification_names + 0, 46}, 1 },
  { {IdentityVerification_names + 46, 61}, 3 },
  { {IdentityVerification_names + 107, 62}, 2 },
  { {IdentityVerification_names + 169, 29}, 0 },
};

static const int IdentityVerification_entries_by_number[] = {
  3, // 0 -> IDENTITY_VERIFICATION_UNKNOWN
  0, // 1 -> IDENTITY_VERIFICATION_NO_PHONE_NUMBER_VERIFIED
  2, // 2 -> IDENTITY_VERIFICATION_PHONE_NUMBER_VERIFIED_NOT_LINKED_TO_GAIA
  1, // 3 -> IDENTITY_VERIFICATION_PHONE_NUMBER_VERIFIED_LINKED_TO_QS_GAIA
};

const std::string& IdentityVerification_Name(
    IdentityVerification value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          IdentityVerification_entries,
          IdentityVerification_entries_by_number,
          4, IdentityVerification_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      IdentityVerification_entries,
      IdentityVerification_entries_by_number,
      4, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     IdentityVerification_strings[idx].get();
}
bool IdentityVerification_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, IdentityVerification* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      IdentityVerification_entries, 4, name, &int_value);
  if (success) {
    *value = static_cast<IdentityVerification>(int_value);
  }
  return success;
}
bool ButtonStatus_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

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

static const char ButtonStatus_names[] =
  "BUTTON_STATUS_CLICK_ACCEPT"
  "BUTTON_STATUS_CLICK_REJECT"
  "BUTTON_STATUS_IGNORE"
  "BUTTON_STATUS_UNKNOWN";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ButtonStatus_entries[] = {
  { {ButtonStatus_names + 0, 26}, 1 },
  { {ButtonStatus_names + 26, 26}, 2 },
  { {ButtonStatus_names + 52, 20}, 3 },
  { {ButtonStatus_names + 72, 21}, 0 },
};

static const int ButtonStatus_entries_by_number[] = {
  3, // 0 -> BUTTON_STATUS_UNKNOWN
  0, // 1 -> BUTTON_STATUS_CLICK_ACCEPT
  1, // 2 -> BUTTON_STATUS_CLICK_REJECT
  2, // 3 -> BUTTON_STATUS_IGNORE
};

const std::string& ButtonStatus_Name(
    ButtonStatus value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          ButtonStatus_entries,
          ButtonStatus_entries_by_number,
          4, ButtonStatus_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      ButtonStatus_entries,
      ButtonStatus_entries_by_number,
      4, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     ButtonStatus_strings[idx].get();
}
bool ButtonStatus_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ButtonStatus* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      ButtonStatus_entries, 4, name, &int_value);
  if (success) {
    *value = static_cast<ButtonStatus>(int_value);
  }
  return success;
}

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

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