// Generated by the protocol buffer compiler.  DO NOT EDIT!
// NO CHECKED-IN PROTOBUF GENCODE
// source: proto/sharing_enums.proto
// Protobuf C++ Version: 6.33.3

#include "proto/sharing_enums.pb.h"

#include <algorithm>
#include <type_traits>
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/generated_message_tctable_impl.h"
#include "google/protobuf/extension_set.h"
#include "google/protobuf/generated_message_util.h"
#include "google/protobuf/wire_format_lite.h"
// @@protoc_insertion_point(includes)

// Must be included last.
#include "google/protobuf/port_def.inc"
PROTOBUF_PRAGMA_INIT_SEG
namespace _pb = ::google::protobuf;
namespace _pbi = ::google::protobuf::internal;
namespace _fl = ::google::protobuf::internal::field_layout;
namespace location {
namespace nearby {
namespace proto {
namespace sharing {
}  // namespace sharing
}  // namespace proto
}  // namespace nearby
}  // namespace location
namespace location {
namespace nearby {
namespace proto {
namespace sharing {
PROTOBUF_CONSTINIT const uint32_t EventType_internal_data_[] = {
    5308416u, 0u, };
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    EventType_strings[81] = {};

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"
    "CLOUD_CREATE_SHARING_REQUEST"
    "CLOUD_DOWNLOAD_END"
    "CLOUD_DOWNLOAD_START"
    "CLOUD_REGISTER_RECEIVER"
    "CLOUD_SHARING_RPC_RESULT"
    "CLOUD_UPLOAD_END"
    "CLOUD_UPLOAD_START"
    "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 ::google::protobuf::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], 28}, 74},
    {{&EventType_names[277], 18}, 79},
    {{&EventType_names[295], 20}, 78},
    {{&EventType_names[315], 23}, 75},
    {{&EventType_names[338], 24}, 80},
    {{&EventType_names[362], 16}, 77},
    {{&EventType_names[378], 18}, 76},
    {{&EventType_names[396], 18}, 46},
    {{&EventType_names[414], 27}, 64},
    {{&EventType_names[441], 14}, 56},
    {{&EventType_names[455], 20}, 4},
    {{&EventType_names[475], 15}, 49},
    {{&EventType_names[490], 21}, 11},
    {{&EventType_names[511], 27}, 29},
    {{&EventType_names[538], 28}, 32},
    {{&EventType_names[566], 21}, 54},
    {{&EventType_names[587], 28}, 53},
    {{&EventType_names[615], 21}, 2},
    {{&EventType_names[636], 20}, 48},
    {{&EventType_names[656], 25}, 61},
    {{&EventType_names[681], 26}, 25},
    {{&EventType_names[707], 16}, 72},
    {{&EventType_names[723], 25}, 68},
    {{&EventType_names[748], 11}, 40},
    {{&EventType_names[759], 15}, 31},
    {{&EventType_names[774], 14}, 42},
    {{&EventType_names[788], 20}, 38},
    {{&EventType_names[808], 21}, 22},
    {{&EventType_names[829], 25}, 21},
    {{&EventType_names[854], 26}, 60},
    {{&EventType_names[880], 17}, 55},
    {{&EventType_names[897], 32}, 43},
    {{&EventType_names[929], 18}, 59},
    {{&EventType_names[947], 28}, 71},
    {{&EventType_names[975], 23}, 18},
    {{&EventType_names[998], 25}, 17},
    {{&EventType_names[1023], 27}, 10},
    {{&EventType_names[1050], 20}, 13},
    {{&EventType_names[1070], 16}, 73},
    {{&EventType_names[1086], 14}, 24},
    {{&EventType_names[1100], 26}, 37},
    {{&EventType_names[1126], 27}, 47},
    {{&EventType_names[1153], 23}, 14},
    {{&EventType_names[1176], 15}, 69},
    {{&EventType_names[1191], 26}, 6},
    {{&EventType_names[1217], 28}, 5},
    {{&EventType_names[1245], 20}, 16},
    {{&EventType_names[1265], 22}, 15},
    {{&EventType_names[1287], 25}, 62},
    {{&EventType_names[1312], 27}, 66},
    {{&EventType_names[1339], 24}, 9},
    {{&EventType_names[1363], 17}, 12},
    {{&EventType_names[1380], 10}, 26},
    {{&EventType_names[1390], 12}, 57},
    {{&EventType_names[1402], 11}, 63},
    {{&EventType_names[1413], 14}, 28},
    {{&EventType_names[1427], 15}, 45},
    {{&EventType_names[1442], 14}, 3},
    {{&EventType_names[1456], 33}, 65},
    {{&EventType_names[1489], 21}, 70},
    {{&EventType_names[1510], 12}, 35},
    {{&EventType_names[1522], 8}, 34},
    {{&EventType_names[1530], 24}, 33},
    {{&EventType_names[1554], 11}, 58},
    {{&EventType_names[1565], 29}, 52},
    {{&EventType_names[1594], 23}, 39},
    {{&EventType_names[1617], 24}, 44},
    {{&EventType_names[1641], 18}, 0},
    {{&EventType_names[1659], 10}, 41},
    {{&EventType_names[1669], 18}, 67},
};

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

const ::std::string& EventType_Name(EventType value) {
  static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      EventType_entries, EventType_entries_by_number, 81,
      EventType_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(EventType_entries,
                                  EventType_entries_by_number,
                                  81, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : EventType_strings[idx].get();
}

bool EventType_Parse(::absl::string_view name, EventType* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      EventType_entries, 81, name, &int_value);
  if (success) {
    *value = static_cast<EventType>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t EventCategory_internal_data_[] = {
    327680u, 0u, };
static ::google::protobuf::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 ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      EventCategory_entries, EventCategory_entries_by_number, 5,
      EventCategory_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(EventCategory_entries,
                                  EventCategory_entries_by_number,
                                  5, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : EventCategory_strings[idx].get();
}

bool EventCategory_Parse(::absl::string_view name, EventCategory* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      EventCategory_entries, 5, name, &int_value);
  if (success) {
    *value = static_cast<EventCategory>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t NearbySharingStatus_internal_data_[] = {
    196608u, 0u, };
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    NearbySharingStatus_strings[3] = {};

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

static const ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      NearbySharingStatus_entries, NearbySharingStatus_entries_by_number, 3,
      NearbySharingStatus_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(NearbySharingStatus_entries,
                                  NearbySharingStatus_entries_by_number,
                                  3, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : NearbySharingStatus_strings[idx].get();
}

bool NearbySharingStatus_Parse(::absl::string_view name, NearbySharingStatus* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      NearbySharingStatus_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<NearbySharingStatus>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t Visibility_internal_data_[] = {
    393216u, 0u, };
static ::google::protobuf::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 ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      Visibility_entries, Visibility_entries_by_number, 6,
      Visibility_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(Visibility_entries,
                                  Visibility_entries_by_number,
                                  6, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : Visibility_strings[idx].get();
}

bool Visibility_Parse(::absl::string_view name, Visibility* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      Visibility_entries, 6, name, &int_value);
  if (success) {
    *value = static_cast<Visibility>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t DataUsage_internal_data_[] = {
    262144u, 0u, };
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    DataUsage_strings[4] = {};

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

static const ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      DataUsage_entries, DataUsage_entries_by_number, 4,
      DataUsage_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(DataUsage_entries,
                                  DataUsage_entries_by_number,
                                  4, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : DataUsage_strings[idx].get();
}

bool DataUsage_Parse(::absl::string_view name, DataUsage* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      DataUsage_entries, 4, name, &int_value);
  if (success) {
    *value = static_cast<DataUsage>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t EstablishConnectionStatus_internal_data_[] = {
    720896u, 0u, };
static ::google::protobuf::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 ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      EstablishConnectionStatus_entries, EstablishConnectionStatus_entries_by_number, 11,
      EstablishConnectionStatus_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(EstablishConnectionStatus_entries,
                                  EstablishConnectionStatus_entries_by_number,
                                  11, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : EstablishConnectionStatus_strings[idx].get();
}

bool EstablishConnectionStatus_Parse(::absl::string_view name, EstablishConnectionStatus* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      EstablishConnectionStatus_entries, 11, name, &int_value);
  if (success) {
    *value = static_cast<EstablishConnectionStatus>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t AttachmentTransmissionStatus_internal_data_[] = {
    2031616u, 0u, };
static ::google::protobuf::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 ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      AttachmentTransmissionStatus_entries, AttachmentTransmissionStatus_entries_by_number, 31,
      AttachmentTransmissionStatus_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(AttachmentTransmissionStatus_entries,
                                  AttachmentTransmissionStatus_entries_by_number,
                                  31, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : AttachmentTransmissionStatus_strings[idx].get();
}

bool AttachmentTransmissionStatus_Parse(::absl::string_view name, AttachmentTransmissionStatus* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      AttachmentTransmissionStatus_entries, 31, name, &int_value);
  if (success) {
    *value = static_cast<AttachmentTransmissionStatus>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t ConnectionLayerStatus_internal_data_[] = {
    1245184u, 0u, };
static ::google::protobuf::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 ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      ConnectionLayerStatus_entries, ConnectionLayerStatus_entries_by_number, 19,
      ConnectionLayerStatus_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(ConnectionLayerStatus_entries,
                                  ConnectionLayerStatus_entries_by_number,
                                  19, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : ConnectionLayerStatus_strings[idx].get();
}

bool ConnectionLayerStatus_Parse(::absl::string_view name, ConnectionLayerStatus* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      ConnectionLayerStatus_entries, 19, name, &int_value);
  if (success) {
    *value = static_cast<ConnectionLayerStatus>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t ProcessReceivedAttachmentsStatus_internal_data_[] = {
    393216u, 0u, };
static ::google::protobuf::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 ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      ProcessReceivedAttachmentsStatus_entries, ProcessReceivedAttachmentsStatus_entries_by_number, 6,
      ProcessReceivedAttachmentsStatus_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(ProcessReceivedAttachmentsStatus_entries,
                                  ProcessReceivedAttachmentsStatus_entries_by_number,
                                  6, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : ProcessReceivedAttachmentsStatus_strings[idx].get();
}

bool ProcessReceivedAttachmentsStatus_Parse(::absl::string_view name, ProcessReceivedAttachmentsStatus* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      ProcessReceivedAttachmentsStatus_entries, 6, name, &int_value);
  if (success) {
    *value = static_cast<ProcessReceivedAttachmentsStatus>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t SessionStatus_internal_data_[] = {
    196608u, 0u, };
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    SessionStatus_strings[3] = {};

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

static const ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      SessionStatus_entries, SessionStatus_entries_by_number, 3,
      SessionStatus_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(SessionStatus_entries,
                                  SessionStatus_entries_by_number,
                                  3, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : SessionStatus_strings[idx].get();
}

bool SessionStatus_Parse(::absl::string_view name, SessionStatus* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      SessionStatus_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<SessionStatus>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t ResponseToIntroduction_internal_data_[] = {
    262144u, 0u, };
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    ResponseToIntroduction_strings[4] = {};

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

static const ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      ResponseToIntroduction_entries, ResponseToIntroduction_entries_by_number, 4,
      ResponseToIntroduction_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(ResponseToIntroduction_entries,
                                  ResponseToIntroduction_entries_by_number,
                                  4, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : ResponseToIntroduction_strings[idx].get();
}

bool ResponseToIntroduction_Parse(::absl::string_view name, ResponseToIntroduction* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      ResponseToIntroduction_entries, 4, name, &int_value);
  if (success) {
    *value = static_cast<ResponseToIntroduction>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t DeviceType_internal_data_[] = {
    458752u, 0u, };
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    DeviceType_strings[7] = {};

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

static const ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      DeviceType_entries, DeviceType_entries_by_number, 7,
      DeviceType_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(DeviceType_entries,
                                  DeviceType_entries_by_number,
                                  7, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : DeviceType_strings[idx].get();
}

bool DeviceType_Parse(::absl::string_view name, DeviceType* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      DeviceType_entries, 7, name, &int_value);
  if (success) {
    *value = static_cast<DeviceType>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t OSType_internal_data_[] = {
    393216u, 0u, };
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    OSType_strings[6] = {};

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

static const ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      OSType_entries, OSType_entries_by_number, 6,
      OSType_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(OSType_entries,
                                  OSType_entries_by_number,
                                  6, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : OSType_strings[idx].get();
}

bool OSType_Parse(::absl::string_view name, OSType* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      OSType_entries, 6, name, &int_value);
  if (success) {
    *value = static_cast<OSType>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t DeviceRelationship_internal_data_[] = {
    262144u, 0u, };
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    DeviceRelationship_strings[4] = {};

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

static const ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      DeviceRelationship_entries, DeviceRelationship_entries_by_number, 4,
      DeviceRelationship_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(DeviceRelationship_entries,
                                  DeviceRelationship_entries_by_number,
                                  4, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : DeviceRelationship_strings[idx].get();
}

bool DeviceRelationship_Parse(::absl::string_view name, DeviceRelationship* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      DeviceRelationship_entries, 4, name, &int_value);
  if (success) {
    *value = static_cast<DeviceRelationship>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t LogSource_internal_data_[] = {
    655360u, 0u, };
static ::google::protobuf::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 ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      LogSource_entries, LogSource_entries_by_number, 10,
      LogSource_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(LogSource_entries,
                                  LogSource_entries_by_number,
                                  10, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : LogSource_strings[idx].get();
}

bool LogSource_Parse(::absl::string_view name, LogSource* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      LogSource_entries, 10, name, &int_value);
  if (success) {
    *value = static_cast<LogSource>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t ServerActionName_internal_data_[] = {
    851968u, 0u, };
static ::google::protobuf::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 ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      ServerActionName_entries, ServerActionName_entries_by_number, 13,
      ServerActionName_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(ServerActionName_entries,
                                  ServerActionName_entries_by_number,
                                  13, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : ServerActionName_strings[idx].get();
}

bool ServerActionName_Parse(::absl::string_view name, ServerActionName* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      ServerActionName_entries, 13, name, &int_value);
  if (success) {
    *value = static_cast<ServerActionName>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t ServerResponseState_internal_data_[] = {
    720896u, 0u, };
static ::google::protobuf::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 ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      ServerResponseState_entries, ServerResponseState_entries_by_number, 11,
      ServerResponseState_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(ServerResponseState_entries,
                                  ServerResponseState_entries_by_number,
                                  11, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : ServerResponseState_strings[idx].get();
}

bool ServerResponseState_Parse(::absl::string_view name, ServerResponseState* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      ServerResponseState_entries, 11, name, &int_value);
  if (success) {
    *value = static_cast<ServerResponseState>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t SyncPurpose_internal_data_[] = {
    1310720u, 0u, };
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    SyncPurpose_strings[20] = {};

static const char SyncPurpose_names[] = {
    "SYNC_EXHAUST_SALT"
    "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"
    "SYNC_QUICKSHARE_IDENTITY_PROVIDER_QUERY"
};

static const ::google::protobuf::internal::EnumEntry SyncPurpose_entries[] = {
    {{&SyncPurpose_names[0], 17}, 18},
    {{&SyncPurpose_names[17], 27}, 15},
    {{&SyncPurpose_names[44], 33}, 5},
    {{&SyncPurpose_names[77], 31}, 2},
    {{&SyncPurpose_names[108], 32}, 11},
    {{&SyncPurpose_names[140], 23}, 3},
    {{&SyncPurpose_names[163], 43}, 17},
    {{&SyncPurpose_names[206], 33}, 6},
    {{&SyncPurpose_names[239], 27}, 1},
    {{&SyncPurpose_names[266], 30}, 4},
    {{&SyncPurpose_names[296], 36}, 16},
    {{&SyncPurpose_names[332], 47}, 13},
    {{&SyncPurpose_names[379], 27}, 12},
    {{&SyncPurpose_names[406], 34}, 10},
    {{&SyncPurpose_names[440], 30}, 8},
    {{&SyncPurpose_names[470], 30}, 7},
    {{&SyncPurpose_names[500], 45}, 9},
    {{&SyncPurpose_names[545], 20}, 0},
    {{&SyncPurpose_names[565], 47}, 14},
    {{&SyncPurpose_names[612], 39}, 19},
};

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

const ::std::string& SyncPurpose_Name(SyncPurpose value) {
  static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      SyncPurpose_entries, SyncPurpose_entries_by_number, 20,
      SyncPurpose_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(SyncPurpose_entries,
                                  SyncPurpose_entries_by_number,
                                  20, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : SyncPurpose_strings[idx].get();
}

bool SyncPurpose_Parse(::absl::string_view name, SyncPurpose* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      SyncPurpose_entries, 20, name, &int_value);
  if (success) {
    *value = static_cast<SyncPurpose>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t ClientRole_internal_data_[] = {
    196608u, 0u, };
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    ClientRole_strings[3] = {};

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

static const ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      ClientRole_entries, ClientRole_entries_by_number, 3,
      ClientRole_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(ClientRole_entries,
                                  ClientRole_entries_by_number,
                                  3, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : ClientRole_strings[idx].get();
}

bool ClientRole_Parse(::absl::string_view name, ClientRole* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      ClientRole_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<ClientRole>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t ScanType_internal_data_[] = {
    327680u, 0u, };
static ::google::protobuf::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 ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      ScanType_entries, ScanType_entries_by_number, 5,
      ScanType_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(ScanType_entries,
                                  ScanType_entries_by_number,
                                  5, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : ScanType_strings[idx].get();
}

bool ScanType_Parse(::absl::string_view name, ScanType* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      ScanType_entries, 5, name, &int_value);
  if (success) {
    *value = static_cast<ScanType>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t ParsingFailedType_internal_data_[] = {
    196608u, 0u, };
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    ParsingFailedType_strings[3] = {};

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

static const ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      ParsingFailedType_entries, ParsingFailedType_entries_by_number, 3,
      ParsingFailedType_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(ParsingFailedType_entries,
                                  ParsingFailedType_entries_by_number,
                                  3, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : ParsingFailedType_strings[idx].get();
}

bool ParsingFailedType_Parse(::absl::string_view name, ParsingFailedType* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      ParsingFailedType_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<ParsingFailedType>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t AdvertisingMode_internal_data_[] = {
    393216u, 0u, };
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    AdvertisingMode_strings[6] = {};

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

static const ::google::protobuf::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], 26}, 5},
    {{&AdvertisingMode_names[133], 24}, 0},
};

static const int AdvertisingMode_entries_by_number[] = {
    5,  // 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
    4,  // 5 -> SUSPENDED_ADVERTISING_MODE
};

const ::std::string& AdvertisingMode_Name(AdvertisingMode value) {
  static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      AdvertisingMode_entries, AdvertisingMode_entries_by_number, 6,
      AdvertisingMode_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(AdvertisingMode_entries,
                                  AdvertisingMode_entries_by_number,
                                  6, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : AdvertisingMode_strings[idx].get();
}

bool AdvertisingMode_Parse(::absl::string_view name, AdvertisingMode* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      AdvertisingMode_entries, 6, name, &int_value);
  if (success) {
    *value = static_cast<AdvertisingMode>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t DiscoveryMode_internal_data_[] = {
    393216u, 0u, };
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    DiscoveryMode_strings[6] = {};

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

static const ::google::protobuf::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], 24}, 5},
    {{&DiscoveryMode_names[123], 22}, 0},
};

static const int DiscoveryMode_entries_by_number[] = {
    5,  // 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
    4,  // 5 -> SUSPENDED_DISCOVERY_MODE
};

const ::std::string& DiscoveryMode_Name(DiscoveryMode value) {
  static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      DiscoveryMode_entries, DiscoveryMode_entries_by_number, 6,
      DiscoveryMode_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(DiscoveryMode_entries,
                                  DiscoveryMode_entries_by_number,
                                  6, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : DiscoveryMode_strings[idx].get();
}

bool DiscoveryMode_Parse(::absl::string_view name, DiscoveryMode* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      DiscoveryMode_entries, 6, name, &int_value);
  if (success) {
    *value = static_cast<DiscoveryMode>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t ActivityName_internal_data_[] = {
    851968u, 0u, };
static ::google::protobuf::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 ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      ActivityName_entries, ActivityName_entries_by_number, 13,
      ActivityName_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(ActivityName_entries,
                                  ActivityName_entries_by_number,
                                  13, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : ActivityName_strings[idx].get();
}

bool ActivityName_Parse(::absl::string_view name, ActivityName* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      ActivityName_entries, 13, name, &int_value);
  if (success) {
    *value = static_cast<ActivityName>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t ConsentType_internal_data_[] = {
    196608u, 0u, };
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    ConsentType_strings[3] = {};

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

static const ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      ConsentType_entries, ConsentType_entries_by_number, 3,
      ConsentType_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(ConsentType_entries,
                                  ConsentType_entries_by_number,
                                  3, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : ConsentType_strings[idx].get();
}

bool ConsentType_Parse(::absl::string_view name, ConsentType* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      ConsentType_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<ConsentType>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t ConsentAcceptanceStatus_internal_data_[] = {
    262144u, 0u, };
static ::google::protobuf::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 ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      ConsentAcceptanceStatus_entries, ConsentAcceptanceStatus_entries_by_number, 4,
      ConsentAcceptanceStatus_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(ConsentAcceptanceStatus_entries,
                                  ConsentAcceptanceStatus_entries_by_number,
                                  4, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : ConsentAcceptanceStatus_strings[idx].get();
}

bool ConsentAcceptanceStatus_Parse(::absl::string_view name, ConsentAcceptanceStatus* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      ConsentAcceptanceStatus_entries, 4, name, &int_value);
  if (success) {
    *value = static_cast<ConsentAcceptanceStatus>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t ApkSource_internal_data_[] = {
    196608u, 0u, };
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    ApkSource_strings[3] = {};

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

static const ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      ApkSource_entries, ApkSource_entries_by_number, 3,
      ApkSource_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(ApkSource_entries,
                                  ApkSource_entries_by_number,
                                  3, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : ApkSource_strings[idx].get();
}

bool ApkSource_Parse(::absl::string_view name, ApkSource* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      ApkSource_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<ApkSource>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t InstallAPKStatus_internal_data_[] = {
    196608u, 0u, };
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    InstallAPKStatus_strings[3] = {};

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

static const ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      InstallAPKStatus_entries, InstallAPKStatus_entries_by_number, 3,
      InstallAPKStatus_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(InstallAPKStatus_entries,
                                  InstallAPKStatus_entries_by_number,
                                  3, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : InstallAPKStatus_strings[idx].get();
}

bool InstallAPKStatus_Parse(::absl::string_view name, InstallAPKStatus* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      InstallAPKStatus_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<InstallAPKStatus>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t VerifyAPKStatus_internal_data_[] = {
    262144u, 0u, };
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    VerifyAPKStatus_strings[4] = {};

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

static const ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      VerifyAPKStatus_entries, VerifyAPKStatus_entries_by_number, 4,
      VerifyAPKStatus_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(VerifyAPKStatus_entries,
                                  VerifyAPKStatus_entries_by_number,
                                  4, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : VerifyAPKStatus_strings[idx].get();
}

bool VerifyAPKStatus_Parse(::absl::string_view name, VerifyAPKStatus* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      VerifyAPKStatus_entries, 4, name, &int_value);
  if (success) {
    *value = static_cast<VerifyAPKStatus>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t ShowNotificationStatus_internal_data_[] = {
    196608u, 0u, };
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    ShowNotificationStatus_strings[3] = {};

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

static const ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      ShowNotificationStatus_entries, ShowNotificationStatus_entries_by_number, 3,
      ShowNotificationStatus_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(ShowNotificationStatus_entries,
                                  ShowNotificationStatus_entries_by_number,
                                  3, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : ShowNotificationStatus_strings[idx].get();
}

bool ShowNotificationStatus_Parse(::absl::string_view name, ShowNotificationStatus* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      ShowNotificationStatus_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<ShowNotificationStatus>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t PermissionRequestResult_internal_data_[] = {
    262144u, 0u, };
static ::google::protobuf::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 ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      PermissionRequestResult_entries, PermissionRequestResult_entries_by_number, 4,
      PermissionRequestResult_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(PermissionRequestResult_entries,
                                  PermissionRequestResult_entries_by_number,
                                  4, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : PermissionRequestResult_strings[idx].get();
}

bool PermissionRequestResult_Parse(::absl::string_view name, PermissionRequestResult* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      PermissionRequestResult_entries, 4, name, &int_value);
  if (success) {
    *value = static_cast<PermissionRequestResult>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t PermissionRequestType_internal_data_[] = {
    393216u, 0u, };
static ::google::protobuf::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 ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      PermissionRequestType_entries, PermissionRequestType_entries_by_number, 6,
      PermissionRequestType_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(PermissionRequestType_entries,
                                  PermissionRequestType_entries_by_number,
                                  6, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : PermissionRequestType_strings[idx].get();
}

bool PermissionRequestType_Parse(::absl::string_view name, PermissionRequestType* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      PermissionRequestType_entries, 6, name, &int_value);
  if (success) {
    *value = static_cast<PermissionRequestType>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t SharingUseCase_internal_data_[] = {
    589824u, 0u, };
static ::google::protobuf::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 ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      SharingUseCase_entries, SharingUseCase_entries_by_number, 9,
      SharingUseCase_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(SharingUseCase_entries,
                                  SharingUseCase_entries_by_number,
                                  9, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : SharingUseCase_strings[idx].get();
}

bool SharingUseCase_Parse(::absl::string_view name, SharingUseCase* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      SharingUseCase_entries, 9, name, &int_value);
  if (success) {
    *value = static_cast<SharingUseCase>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t AppCrashReason_internal_data_[] = {
    65536u, 0u, };
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    AppCrashReason_strings[1] = {};

static const char AppCrashReason_names[] = {
    "APP_CRASH_REASON_UNKNOWN"
};

static const ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      AppCrashReason_entries, AppCrashReason_entries_by_number, 1,
      AppCrashReason_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(AppCrashReason_entries,
                                  AppCrashReason_entries_by_number,
                                  1, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : AppCrashReason_strings[idx].get();
}

bool AppCrashReason_Parse(::absl::string_view name, AppCrashReason* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      AppCrashReason_entries, 1, name, &int_value);
  if (success) {
    *value = static_cast<AppCrashReason>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t AttachmentSourceType_internal_data_[] = {
    458752u, 0u, };
static ::google::protobuf::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 ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      AttachmentSourceType_entries, AttachmentSourceType_entries_by_number, 7,
      AttachmentSourceType_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(AttachmentSourceType_entries,
                                  AttachmentSourceType_entries_by_number,
                                  7, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : AttachmentSourceType_strings[idx].get();
}

bool AttachmentSourceType_Parse(::absl::string_view name, AttachmentSourceType* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      AttachmentSourceType_entries, 7, name, &int_value);
  if (success) {
    *value = static_cast<AttachmentSourceType>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t PreferencesAction_internal_data_[] = {
    786432u, 0u, };
static ::google::protobuf::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 ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      PreferencesAction_entries, PreferencesAction_entries_by_number, 12,
      PreferencesAction_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(PreferencesAction_entries,
                                  PreferencesAction_entries_by_number,
                                  12, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : PreferencesAction_strings[idx].get();
}

bool PreferencesAction_Parse(::absl::string_view name, PreferencesAction* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      PreferencesAction_entries, 12, name, &int_value);
  if (success) {
    *value = static_cast<PreferencesAction>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t PreferencesActionStatus_internal_data_[] = {
    196608u, 0u, };
static ::google::protobuf::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 ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      PreferencesActionStatus_entries, PreferencesActionStatus_entries_by_number, 3,
      PreferencesActionStatus_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(PreferencesActionStatus_entries,
                                  PreferencesActionStatus_entries_by_number,
                                  3, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : PreferencesActionStatus_strings[idx].get();
}

bool PreferencesActionStatus_Parse(::absl::string_view name, PreferencesActionStatus* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      PreferencesActionStatus_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<PreferencesActionStatus>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t FastInitState_internal_data_[] = {
    262144u, 0u, };
static ::google::protobuf::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 ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      FastInitState_entries, FastInitState_entries_by_number, 4,
      FastInitState_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(FastInitState_entries,
                                  FastInitState_entries_by_number,
                                  4, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : FastInitState_strings[idx].get();
}

bool FastInitState_Parse(::absl::string_view name, FastInitState* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      FastInitState_entries, 4, name, &int_value);
  if (success) {
    *value = static_cast<FastInitState>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t FastInitType_internal_data_[] = {
    196608u, 0u, };
static ::google::protobuf::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 ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      FastInitType_entries, FastInitType_entries_by_number, 3,
      FastInitType_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(FastInitType_entries,
                                  FastInitType_entries_by_number,
                                  3, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : FastInitType_strings[idx].get();
}

bool FastInitType_Parse(::absl::string_view name, FastInitType* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      FastInitType_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<FastInitType>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t DesktopNotification_internal_data_[] = {
    393216u, 0u, };
static ::google::protobuf::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 ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      DesktopNotification_entries, DesktopNotification_entries_by_number, 6,
      DesktopNotification_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(DesktopNotification_entries,
                                  DesktopNotification_entries_by_number,
                                  6, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : DesktopNotification_strings[idx].get();
}

bool DesktopNotification_Parse(::absl::string_view name, DesktopNotification* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      DesktopNotification_entries, 6, name, &int_value);
  if (success) {
    *value = static_cast<DesktopNotification>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t DesktopTransferEventType_internal_data_[] = {
    655360u, 0u, };
static ::google::protobuf::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 ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      DesktopTransferEventType_entries, DesktopTransferEventType_entries_by_number, 10,
      DesktopTransferEventType_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(DesktopTransferEventType_entries,
                                  DesktopTransferEventType_entries_by_number,
                                  10, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : DesktopTransferEventType_strings[idx].get();
}

bool DesktopTransferEventType_Parse(::absl::string_view name, DesktopTransferEventType* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      DesktopTransferEventType_entries, 10, name, &int_value);
  if (success) {
    *value = static_cast<DesktopTransferEventType>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t DecryptCertificateFailureStatus_internal_data_[] = {
    458752u, 0u, };
static ::google::protobuf::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 ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      DecryptCertificateFailureStatus_entries, DecryptCertificateFailureStatus_entries_by_number, 7,
      DecryptCertificateFailureStatus_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(DecryptCertificateFailureStatus_entries,
                                  DecryptCertificateFailureStatus_entries_by_number,
                                  7, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : DecryptCertificateFailureStatus_strings[idx].get();
}

bool DecryptCertificateFailureStatus_Parse(::absl::string_view name, DecryptCertificateFailureStatus* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      DecryptCertificateFailureStatus_entries, 7, name, &int_value);
  if (success) {
    *value = static_cast<DecryptCertificateFailureStatus>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t ContactAccess_internal_data_[] = {
    327680u, 0u, };
static ::google::protobuf::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 ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      ContactAccess_entries, ContactAccess_entries_by_number, 5,
      ContactAccess_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(ContactAccess_entries,
                                  ContactAccess_entries_by_number,
                                  5, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : ContactAccess_strings[idx].get();
}

bool ContactAccess_Parse(::absl::string_view name, ContactAccess* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      ContactAccess_entries, 5, name, &int_value);
  if (success) {
    *value = static_cast<ContactAccess>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t IdentityVerification_internal_data_[] = {
    262144u, 0u, };
static ::google::protobuf::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 ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      IdentityVerification_entries, IdentityVerification_entries_by_number, 4,
      IdentityVerification_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(IdentityVerification_entries,
                                  IdentityVerification_entries_by_number,
                                  4, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : IdentityVerification_strings[idx].get();
}

bool IdentityVerification_Parse(::absl::string_view name, IdentityVerification* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      IdentityVerification_entries, 4, name, &int_value);
  if (success) {
    *value = static_cast<IdentityVerification>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t ButtonStatus_internal_data_[] = {
    262144u, 0u, };
static ::google::protobuf::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 ::google::protobuf::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 kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      ButtonStatus_entries, ButtonStatus_entries_by_number, 4,
      ButtonStatus_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(ButtonStatus_entries,
                                  ButtonStatus_entries_by_number,
                                  4, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : ButtonStatus_strings[idx].get();
}

bool ButtonStatus_Parse(::absl::string_view name, ButtonStatus* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      ButtonStatus_entries, 4, name, &int_value);
  if (success) {
    *value = static_cast<ButtonStatus>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t CloudCreateSharingResult_internal_data_[] = {
    720896u, 0u, };
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    CloudCreateSharingResult_strings[11] = {};

static const char CloudCreateSharingResult_names[] = {
    "CLOUD_CREATE_SHARING_RESULT_ALREADY_EXIST"
    "CLOUD_CREATE_SHARING_RESULT_ALREADY_STARTED"
    "CLOUD_CREATE_SHARING_RESULT_FILE_LIMIT_EXCEED_COUNT"
    "CLOUD_CREATE_SHARING_RESULT_FILE_LIMIT_EXCEED_SIZE"
    "CLOUD_CREATE_SHARING_RESULT_INVALID_ARGUMENT"
    "CLOUD_CREATE_SHARING_RESULT_NETWORK_ERROR"
    "CLOUD_CREATE_SHARING_RESULT_REMOTE_ERROR"
    "CLOUD_CREATE_SHARING_RESULT_SIGN_IN_REQUIRE"
    "CLOUD_CREATE_SHARING_RESULT_SUCCESS"
    "CLOUD_CREATE_SHARING_RESULT_SUCCESS_NO_NOTIFICATION"
    "CLOUD_CREATE_SHARING_RESULT_UNKNOWN"
};

static const ::google::protobuf::internal::EnumEntry CloudCreateSharingResult_entries[] = {
    {{&CloudCreateSharingResult_names[0], 41}, 3},
    {{&CloudCreateSharingResult_names[41], 43}, 4},
    {{&CloudCreateSharingResult_names[84], 51}, 8},
    {{&CloudCreateSharingResult_names[135], 50}, 9},
    {{&CloudCreateSharingResult_names[185], 44}, 6},
    {{&CloudCreateSharingResult_names[229], 41}, 5},
    {{&CloudCreateSharingResult_names[270], 40}, 7},
    {{&CloudCreateSharingResult_names[310], 43}, 2},
    {{&CloudCreateSharingResult_names[353], 35}, 1},
    {{&CloudCreateSharingResult_names[388], 51}, 10},
    {{&CloudCreateSharingResult_names[439], 35}, 0},
};

static const int CloudCreateSharingResult_entries_by_number[] = {
    10,  // 0 -> CLOUD_CREATE_SHARING_RESULT_UNKNOWN
    8,  // 1 -> CLOUD_CREATE_SHARING_RESULT_SUCCESS
    7,  // 2 -> CLOUD_CREATE_SHARING_RESULT_SIGN_IN_REQUIRE
    0,  // 3 -> CLOUD_CREATE_SHARING_RESULT_ALREADY_EXIST
    1,  // 4 -> CLOUD_CREATE_SHARING_RESULT_ALREADY_STARTED
    5,  // 5 -> CLOUD_CREATE_SHARING_RESULT_NETWORK_ERROR
    4,  // 6 -> CLOUD_CREATE_SHARING_RESULT_INVALID_ARGUMENT
    6,  // 7 -> CLOUD_CREATE_SHARING_RESULT_REMOTE_ERROR
    2,  // 8 -> CLOUD_CREATE_SHARING_RESULT_FILE_LIMIT_EXCEED_COUNT
    3,  // 9 -> CLOUD_CREATE_SHARING_RESULT_FILE_LIMIT_EXCEED_SIZE
    9,  // 10 -> CLOUD_CREATE_SHARING_RESULT_SUCCESS_NO_NOTIFICATION
};

const ::std::string& CloudCreateSharingResult_Name(CloudCreateSharingResult value) {
  static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      CloudCreateSharingResult_entries, CloudCreateSharingResult_entries_by_number, 11,
      CloudCreateSharingResult_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(CloudCreateSharingResult_entries,
                                  CloudCreateSharingResult_entries_by_number,
                                  11, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : CloudCreateSharingResult_strings[idx].get();
}

bool CloudCreateSharingResult_Parse(::absl::string_view name, CloudCreateSharingResult* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      CloudCreateSharingResult_entries, 11, name, &int_value);
  if (success) {
    *value = static_cast<CloudCreateSharingResult>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t CloudRegisterReceiverResult_internal_data_[] = {
    1114112u, 0u, };
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    CloudRegisterReceiverResult_strings[17] = {};

static const char CloudRegisterReceiverResult_names[] = {
    "CLOUD_REGISTER_RECEIVER_RESULT_ABORTED"
    "CLOUD_REGISTER_RECEIVER_RESULT_ALREADY_EXISTS"
    "CLOUD_REGISTER_RECEIVER_RESULT_CANCELLED"
    "CLOUD_REGISTER_RECEIVER_RESULT_DATA_LOSS"
    "CLOUD_REGISTER_RECEIVER_RESULT_DEADLINE_EXCEEDED"
    "CLOUD_REGISTER_RECEIVER_RESULT_FAILED_PRECONDITION"
    "CLOUD_REGISTER_RECEIVER_RESULT_INTERNAL"
    "CLOUD_REGISTER_RECEIVER_RESULT_INVALID_ARGUMENT"
    "CLOUD_REGISTER_RECEIVER_RESULT_NOT_FOUND"
    "CLOUD_REGISTER_RECEIVER_RESULT_OUT_OF_RANGE"
    "CLOUD_REGISTER_RECEIVER_RESULT_PERMISSION_DENIED"
    "CLOUD_REGISTER_RECEIVER_RESULT_RESOURCE_EXHAUSTED"
    "CLOUD_REGISTER_RECEIVER_RESULT_SUCCESS"
    "CLOUD_REGISTER_RECEIVER_RESULT_UNAUTHENTICATED"
    "CLOUD_REGISTER_RECEIVER_RESULT_UNAVAILABLE"
    "CLOUD_REGISTER_RECEIVER_RESULT_UNIMPLEMENTED"
    "CLOUD_REGISTER_RECEIVER_RESULT_UNKNOWN"
};

static const ::google::protobuf::internal::EnumEntry CloudRegisterReceiverResult_entries[] = {
    {{&CloudRegisterReceiverResult_names[0], 38}, 13},
    {{&CloudRegisterReceiverResult_names[38], 45}, 9},
    {{&CloudRegisterReceiverResult_names[83], 40}, 11},
    {{&CloudRegisterReceiverResult_names[123], 40}, 16},
    {{&CloudRegisterReceiverResult_names[163], 48}, 3},
    {{&CloudRegisterReceiverResult_names[211], 50}, 12},
    {{&CloudRegisterReceiverResult_names[261], 39}, 4},
    {{&CloudRegisterReceiverResult_names[300], 47}, 2},
    {{&CloudRegisterReceiverResult_names[347], 40}, 8},
    {{&CloudRegisterReceiverResult_names[387], 43}, 14},
    {{&CloudRegisterReceiverResult_names[430], 48}, 7},
    {{&CloudRegisterReceiverResult_names[478], 49}, 5},
    {{&CloudRegisterReceiverResult_names[527], 38}, 1},
    {{&CloudRegisterReceiverResult_names[565], 46}, 10},
    {{&CloudRegisterReceiverResult_names[611], 42}, 6},
    {{&CloudRegisterReceiverResult_names[653], 44}, 15},
    {{&CloudRegisterReceiverResult_names[697], 38}, 0},
};

static const int CloudRegisterReceiverResult_entries_by_number[] = {
    16,  // 0 -> CLOUD_REGISTER_RECEIVER_RESULT_UNKNOWN
    12,  // 1 -> CLOUD_REGISTER_RECEIVER_RESULT_SUCCESS
    7,  // 2 -> CLOUD_REGISTER_RECEIVER_RESULT_INVALID_ARGUMENT
    4,  // 3 -> CLOUD_REGISTER_RECEIVER_RESULT_DEADLINE_EXCEEDED
    6,  // 4 -> CLOUD_REGISTER_RECEIVER_RESULT_INTERNAL
    11,  // 5 -> CLOUD_REGISTER_RECEIVER_RESULT_RESOURCE_EXHAUSTED
    14,  // 6 -> CLOUD_REGISTER_RECEIVER_RESULT_UNAVAILABLE
    10,  // 7 -> CLOUD_REGISTER_RECEIVER_RESULT_PERMISSION_DENIED
    8,  // 8 -> CLOUD_REGISTER_RECEIVER_RESULT_NOT_FOUND
    1,  // 9 -> CLOUD_REGISTER_RECEIVER_RESULT_ALREADY_EXISTS
    13,  // 10 -> CLOUD_REGISTER_RECEIVER_RESULT_UNAUTHENTICATED
    2,  // 11 -> CLOUD_REGISTER_RECEIVER_RESULT_CANCELLED
    5,  // 12 -> CLOUD_REGISTER_RECEIVER_RESULT_FAILED_PRECONDITION
    0,  // 13 -> CLOUD_REGISTER_RECEIVER_RESULT_ABORTED
    9,  // 14 -> CLOUD_REGISTER_RECEIVER_RESULT_OUT_OF_RANGE
    15,  // 15 -> CLOUD_REGISTER_RECEIVER_RESULT_UNIMPLEMENTED
    3,  // 16 -> CLOUD_REGISTER_RECEIVER_RESULT_DATA_LOSS
};

const ::std::string& CloudRegisterReceiverResult_Name(CloudRegisterReceiverResult value) {
  static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      CloudRegisterReceiverResult_entries, CloudRegisterReceiverResult_entries_by_number, 17,
      CloudRegisterReceiverResult_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(CloudRegisterReceiverResult_entries,
                                  CloudRegisterReceiverResult_entries_by_number,
                                  17, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : CloudRegisterReceiverResult_strings[idx].get();
}

bool CloudRegisterReceiverResult_Parse(::absl::string_view name, CloudRegisterReceiverResult* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      CloudRegisterReceiverResult_entries, 17, name, &int_value);
  if (success) {
    *value = static_cast<CloudRegisterReceiverResult>(int_value);
  }
  return success;
}
PROTOBUF_CONSTINIT const uint32_t CloudActionType_internal_data_[] = {
    196608u, 0u, };
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    CloudActionType_strings[3] = {};

static const char CloudActionType_names[] = {
    "CLOUD_ACTION_TYPE_NORMAL"
    "CLOUD_ACTION_TYPE_RETRY"
    "CLOUD_ACTION_TYPE_UNKNOWN"
};

static const ::google::protobuf::internal::EnumEntry CloudActionType_entries[] = {
    {{&CloudActionType_names[0], 24}, 1},
    {{&CloudActionType_names[24], 23}, 2},
    {{&CloudActionType_names[47], 25}, 0},
};

static const int CloudActionType_entries_by_number[] = {
    2,  // 0 -> CLOUD_ACTION_TYPE_UNKNOWN
    0,  // 1 -> CLOUD_ACTION_TYPE_NORMAL
    1,  // 2 -> CLOUD_ACTION_TYPE_RETRY
};

const ::std::string& CloudActionType_Name(CloudActionType value) {
  static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      CloudActionType_entries, CloudActionType_entries_by_number, 3,
      CloudActionType_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(CloudActionType_entries,
                                  CloudActionType_entries_by_number,
                                  3, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : CloudActionType_strings[idx].get();
}

bool CloudActionType_Parse(::absl::string_view name, CloudActionType* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      CloudActionType_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<CloudActionType>(int_value);
  }
  return success;
}
// @@protoc_insertion_point(namespace_scope)
}  // namespace sharing
}  // namespace proto
}  // namespace nearby
}  // namespace location
namespace google {
namespace protobuf {
}  // namespace protobuf
}  // namespace google
// @@protoc_insertion_point(global_scope)
#include "google/protobuf/port_undef.inc"