Compile protos with v33.3

2026-09-14 14:46:12 -04:00 · 2026-01-12 19:41:09 -05:00
parent 505bd6b050
commit 11ca9fc683
42 changed files with 169733 additions and 129110 deletions
@@ -1,85 +1,181 @@
 // Generated by the protocol buffer compiler.  DO NOT EDIT!
+// NO CHECKED-IN PROTOBUF GENCODE
 // source: proto/errorcode/error_code_enums.proto
+// Protobuf C++ Version: 6.33.3

-#ifndef GOOGLE_PROTOBUF_INCLUDED_proto_2ferrorcode_2ferror_5fcode_5fenums_2eproto
-#define GOOGLE_PROTOBUF_INCLUDED_proto_2ferrorcode_2ferror_5fcode_5fenums_2eproto
+#ifndef proto_2ferrorcode_2ferror_5fcode_5fenums_2eproto_2epb_2eh
+#define proto_2ferrorcode_2ferror_5fcode_5fenums_2eproto_2epb_2eh

 #include <limits>
 #include <string>
+#include <type_traits>
+#include <utility>

-#include <google/protobuf/port_def.inc>
-#if PROTOBUF_VERSION < 3019000
-#error This file was generated by a newer version of protoc which is
-#error incompatible with your Protocol Buffer headers. Please update
-#error your headers.
+#include "google/protobuf/runtime_version.h"
+#if PROTOBUF_VERSION != 6033003
+#error "Protobuf C++ gencode is built with an incompatible version of"
+#error "Protobuf C++ headers/runtime. See"
+#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp"
 #endif
-#if 3019001 < PROTOBUF_MIN_PROTOC_VERSION
-#error This file was generated by an older version of protoc which is
-#error incompatible with your Protocol Buffer headers. Please
-#error regenerate this file with a newer version of protoc.
-#endif
-
-#include <google/protobuf/port_undef.inc>
-#include <google/protobuf/io/coded_stream.h>
-#include <google/protobuf/arena.h>
-#include <google/protobuf/arenastring.h>
-#include <google/protobuf/generated_message_table_driven.h>
-#include <google/protobuf/generated_message_util.h>
-#include <google/protobuf/metadata_lite.h>
-#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
-#include <google/protobuf/extension_set.h>  // IWYU pragma: export
-#include <google/protobuf/generated_enum_util.h>
+#include "google/protobuf/io/coded_stream.h"
+#include "google/protobuf/arena.h"
+#include "google/protobuf/arenastring.h"
+#include "google/protobuf/generated_message_tctable_decl.h"
+#include "google/protobuf/generated_message_util.h"
+#include "google/protobuf/metadata_lite.h"
+#include "google/protobuf/repeated_field.h"  // IWYU pragma: export
+#include "google/protobuf/extension_set.h"  // IWYU pragma: export
+#include "google/protobuf/generated_enum_util.h"
 // @@protoc_insertion_point(includes)
-#include <google/protobuf/port_def.inc>
+
+// Must be included last.
+#include "google/protobuf/port_def.inc"
+
 #define PROTOBUF_INTERNAL_EXPORT_proto_2ferrorcode_2ferror_5fcode_5fenums_2eproto
-PROTOBUF_NAMESPACE_OPEN
+
+namespace google {
+namespace protobuf {
 namespace internal {
-class AnyMetadata;
+template <typename T>
+::absl::string_view GetAnyMessageName();
 }  // namespace internal
-PROTOBUF_NAMESPACE_CLOSE
+}  // namespace protobuf
+}  // namespace google

 // Internal implementation detail -- do not use these members.
 struct TableStruct_proto_2ferrorcode_2ferror_5fcode_5fenums_2eproto {
-  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
-    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
-  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
-    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
-  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[1]
-    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
-  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
-  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
-  static const uint32_t offsets[];
+  static const ::uint32_t offsets[];
 };
-PROTOBUF_NAMESPACE_OPEN
-PROTOBUF_NAMESPACE_CLOSE
 namespace location {
 namespace nearby {
 namespace errorcode {
 namespace proto {
+enum AcceptConnectionError : int;
+extern const uint32_t AcceptConnectionError_internal_data_[];
+enum CommonError : int;
+extern const uint32_t CommonError_internal_data_[];
+enum ConnectError : int;
+extern const uint32_t ConnectError_internal_data_[];
+enum Description : int;
+extern const uint32_t Description_internal_data_[];
+enum DisconnectError : int;
+extern const uint32_t DisconnectError_internal_data_[];
+enum ErrorType : int;
+extern const uint32_t ErrorType_internal_data_[];
+enum Event : int;
+extern const uint32_t Event_internal_data_[];
+enum ReceivePayloadError : int;
+extern const uint32_t ReceivePayloadError_internal_data_[];
+enum RejectConnectionError : int;
+extern const uint32_t RejectConnectionError_internal_data_[];
+enum SendPayloadError : int;
+extern const uint32_t SendPayloadError_internal_data_[];
+enum StartAdvertisingError : int;
+extern const uint32_t StartAdvertisingError_internal_data_[];
+enum StartDiscoveringError : int;
+extern const uint32_t StartDiscoveringError_internal_data_[];
+enum StartListeningIncomingConnectionError : int;
+extern const uint32_t StartListeningIncomingConnectionError_internal_data_[];
+enum StopAdvertisingError : int;
+extern const uint32_t StopAdvertisingError_internal_data_[];
+enum StopDiscoveringError : int;
+extern const uint32_t StopDiscoveringError_internal_data_[];
+enum StopListeningIncomingConnectionError : int;
+extern const uint32_t StopListeningIncomingConnectionError_internal_data_[];
+enum UpgradeError : int;
+extern const uint32_t UpgradeError_internal_data_[];
+}  // namespace proto
+}  // namespace errorcode
+}  // namespace nearby
+}  // namespace location
+namespace google {
+namespace protobuf {
+template <>
+internal::EnumTraitsT<::location::nearby::errorcode::proto::AcceptConnectionError_internal_data_>
+    internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::AcceptConnectionError>;
+template <>
+internal::EnumTraitsT<::location::nearby::errorcode::proto::CommonError_internal_data_>
+    internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::CommonError>;
+template <>
+internal::EnumTraitsT<::location::nearby::errorcode::proto::ConnectError_internal_data_>
+    internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::ConnectError>;
+template <>
+internal::EnumTraitsT<::location::nearby::errorcode::proto::Description_internal_data_>
+    internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::Description>;
+template <>
+internal::EnumTraitsT<::location::nearby::errorcode::proto::DisconnectError_internal_data_>
+    internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::DisconnectError>;
+template <>
+internal::EnumTraitsT<::location::nearby::errorcode::proto::ErrorType_internal_data_>
+    internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::ErrorType>;
+template <>
+internal::EnumTraitsT<::location::nearby::errorcode::proto::Event_internal_data_>
+    internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::Event>;
+template <>
+internal::EnumTraitsT<::location::nearby::errorcode::proto::ReceivePayloadError_internal_data_>
+    internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::ReceivePayloadError>;
+template <>
+internal::EnumTraitsT<::location::nearby::errorcode::proto::RejectConnectionError_internal_data_>
+    internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::RejectConnectionError>;
+template <>
+internal::EnumTraitsT<::location::nearby::errorcode::proto::SendPayloadError_internal_data_>
+    internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::SendPayloadError>;
+template <>
+internal::EnumTraitsT<::location::nearby::errorcode::proto::StartAdvertisingError_internal_data_>
+    internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::StartAdvertisingError>;
+template <>
+internal::EnumTraitsT<::location::nearby::errorcode::proto::StartDiscoveringError_internal_data_>
+    internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::StartDiscoveringError>;
+template <>
+internal::EnumTraitsT<::location::nearby::errorcode::proto::StartListeningIncomingConnectionError_internal_data_>
+    internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::StartListeningIncomingConnectionError>;
+template <>
+internal::EnumTraitsT<::location::nearby::errorcode::proto::StopAdvertisingError_internal_data_>
+    internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::StopAdvertisingError>;
+template <>
+internal::EnumTraitsT<::location::nearby::errorcode::proto::StopDiscoveringError_internal_data_>
+    internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::StopDiscoveringError>;
+template <>
+internal::EnumTraitsT<::location::nearby::errorcode::proto::StopListeningIncomingConnectionError_internal_data_>
+    internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::StopListeningIncomingConnectionError>;
+template <>
+internal::EnumTraitsT<::location::nearby::errorcode::proto::UpgradeError_internal_data_>
+    internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::UpgradeError>;
+}  // namespace protobuf
+}  // namespace google

+namespace location {
+namespace nearby {
+namespace errorcode {
+namespace proto {
 enum ErrorType : int {
  UNKNOWN_TYPE = 0,
  DEVELOPING = 1,
  DEVICE = 2,
  SYSTEM = 3,
  NETWORK = 4,
-  OTHERS = 5
+  OTHERS = 5,
 };
-bool ErrorType_IsValid(int value);
-constexpr ErrorType ErrorType_MIN = UNKNOWN_TYPE;
-constexpr ErrorType ErrorType_MAX = OTHERS;
-constexpr int ErrorType_ARRAYSIZE = ErrorType_MAX + 1;

-const std::string& ErrorType_Name(ErrorType value);
-template<typename T>
-inline const std::string& ErrorType_Name(T enum_t_value) {
+extern const uint32_t ErrorType_internal_data_[];
+inline constexpr ErrorType ErrorType_MIN =
+    static_cast<ErrorType>(0);
+inline constexpr ErrorType ErrorType_MAX =
+    static_cast<ErrorType>(5);
+inline bool ErrorType_IsValid(int value) {
+  return 0 <= value && value <= 5;
+}
+inline constexpr int ErrorType_ARRAYSIZE = 5 + 1;
+const ::std::string& ErrorType_Name(ErrorType value);
+template <typename T>
+const ::std::string& ErrorType_Name(T value) {
  static_assert(::std::is_same<T, ErrorType>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function ErrorType_Name.");
-  return ErrorType_Name(static_cast<ErrorType>(enum_t_value));
+                    ::std::is_integral<T>::value,
+                "Incorrect type passed to ErrorType_Name().");
+  return ErrorType_Name(static_cast<ErrorType>(value));
 }
 bool ErrorType_Parse(
-    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ErrorType* value);
+    ::absl::string_view name, ErrorType* PROTOBUF_NONNULL value);
 enum Event : int {
  UNKNOWN_EVENT = 0,
  START_ADVERTISING = 1,
@@ -95,23 +191,28 @@ enum Event : int {
  SEND_PAYLOAD = 11,
  CANCEL_PAYLOAD = 12,
  RECEIVE_PAYLOAD = 13,
-  UPGRADE = 14
+  UPGRADE = 14,
 };
-bool Event_IsValid(int value);
-constexpr Event Event_MIN = UNKNOWN_EVENT;
-constexpr Event Event_MAX = UPGRADE;
-constexpr int Event_ARRAYSIZE = Event_MAX + 1;

-const std::string& Event_Name(Event value);
-template<typename T>
-inline const std::string& Event_Name(T enum_t_value) {
+extern const uint32_t Event_internal_data_[];
+inline constexpr Event Event_MIN =
+    static_cast<Event>(0);
+inline constexpr Event Event_MAX =
+    static_cast<Event>(14);
+inline bool Event_IsValid(int value) {
+  return 0 <= value && value <= 14;
+}
+inline constexpr int Event_ARRAYSIZE = 14 + 1;
+const ::std::string& Event_Name(Event value);
+template <typename T>
+const ::std::string& Event_Name(T value) {
  static_assert(::std::is_same<T, Event>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function Event_Name.");
-  return Event_Name(static_cast<Event>(enum_t_value));
+                    ::std::is_integral<T>::value,
+                "Incorrect type passed to Event_Name().");
+  return Event_Name(static_cast<Event>(value));
 }
 bool Event_Parse(
-    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Event* value);
+    ::absl::string_view name, Event* PROTOBUF_NONNULL value);
 enum CommonError : int {
  UNKNOWN_ERROR = 0,
  INVALID_PARAMETER = 1,
@@ -119,23 +220,28 @@ enum CommonError : int {
  UNEXPECTED_MEDIUM_STATE = 3,
  OUT_OF_RESOURCE = 4,
  FLOW_CANCELED = 5,
-  UNEXPECTED_CALL = 6
+  UNEXPECTED_CALL = 6,
 };
-bool CommonError_IsValid(int value);
-constexpr CommonError CommonError_MIN = UNKNOWN_ERROR;
-constexpr CommonError CommonError_MAX = UNEXPECTED_CALL;
-constexpr int CommonError_ARRAYSIZE = CommonError_MAX + 1;

-const std::string& CommonError_Name(CommonError value);
-template<typename T>
-inline const std::string& CommonError_Name(T enum_t_value) {
+extern const uint32_t CommonError_internal_data_[];
+inline constexpr CommonError CommonError_MIN =
+    static_cast<CommonError>(0);
+inline constexpr CommonError CommonError_MAX =
+    static_cast<CommonError>(6);
+inline bool CommonError_IsValid(int value) {
+  return 0 <= value && value <= 6;
+}
+inline constexpr int CommonError_ARRAYSIZE = 6 + 1;
+const ::std::string& CommonError_Name(CommonError value);
+template <typename T>
+const ::std::string& CommonError_Name(T value) {
  static_assert(::std::is_same<T, CommonError>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function CommonError_Name.");
-  return CommonError_Name(static_cast<CommonError>(enum_t_value));
+                    ::std::is_integral<T>::value,
+                "Incorrect type passed to CommonError_Name().");
+  return CommonError_Name(static_cast<CommonError>(value));
 }
 bool CommonError_Parse(
-    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CommonError* value);
+    ::absl::string_view name, CommonError* PROTOBUF_NONNULL value);
 enum StartAdvertisingError : int {
  MULTIPLE_FAST_ADVERTISEMENT_NOT_ALLOWED = 31,
  FAST_ADVERTISEMENT_ALREADY_ADVERTISED = 32,
@@ -151,45 +257,55 @@ enum StartAdvertisingError : int {
  SHOULD_ACCEPT_CONNECTIONS_BEFORE_ADVERTISING_ON_WIFI_LAN = 44,
  ACQUIRE_WIFI_AWARE_SESSION_FAILED = 45,
  UNKNOWN_START_ADVERTISING_ERROR = 46,
-  AWARE_UPDATE_PUBLISHING_FAILED = 47
+  AWARE_UPDATE_PUBLISHING_FAILED = 47,
 };
-bool StartAdvertisingError_IsValid(int value);
-constexpr StartAdvertisingError StartAdvertisingError_MIN = MULTIPLE_FAST_ADVERTISEMENT_NOT_ALLOWED;
-constexpr StartAdvertisingError StartAdvertisingError_MAX = AWARE_UPDATE_PUBLISHING_FAILED;
-constexpr int StartAdvertisingError_ARRAYSIZE = StartAdvertisingError_MAX + 1;

-const std::string& StartAdvertisingError_Name(StartAdvertisingError value);
-template<typename T>
-inline const std::string& StartAdvertisingError_Name(T enum_t_value) {
+extern const uint32_t StartAdvertisingError_internal_data_[];
+inline constexpr StartAdvertisingError StartAdvertisingError_MIN =
+    static_cast<StartAdvertisingError>(31);
+inline constexpr StartAdvertisingError StartAdvertisingError_MAX =
+    static_cast<StartAdvertisingError>(47);
+inline bool StartAdvertisingError_IsValid(int value) {
+  return 0 <= value && value <= 47 && ((280785634459648u >> value) & 1) != 0;
+}
+inline constexpr int StartAdvertisingError_ARRAYSIZE = 47 + 1;
+const ::std::string& StartAdvertisingError_Name(StartAdvertisingError value);
+template <typename T>
+const ::std::string& StartAdvertisingError_Name(T value) {
  static_assert(::std::is_same<T, StartAdvertisingError>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function StartAdvertisingError_Name.");
-  return StartAdvertisingError_Name(static_cast<StartAdvertisingError>(enum_t_value));
+                    ::std::is_integral<T>::value,
+                "Incorrect type passed to StartAdvertisingError_Name().");
+  return StartAdvertisingError_Name(static_cast<StartAdvertisingError>(value));
 }
 bool StartAdvertisingError_Parse(
-    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StartAdvertisingError* value);
+    ::absl::string_view name, StartAdvertisingError* PROTOBUF_NONNULL value);
 enum StopAdvertisingError : int {
  STOP_ADVERTISING_FAILED = 31,
  RESTORE_BLUETOOTH_NAME_FAILED = 32,
  STOP_LEGACY_ADVERTISING_FAILED = 33,
  STOP_EXTENDED_ADVERTISING_FAILED = 34,
-  UNKNOWN_STOP_ADVERTISING_ERROR = 35
+  UNKNOWN_STOP_ADVERTISING_ERROR = 35,
 };
-bool StopAdvertisingError_IsValid(int value);
-constexpr StopAdvertisingError StopAdvertisingError_MIN = STOP_ADVERTISING_FAILED;
-constexpr StopAdvertisingError StopAdvertisingError_MAX = UNKNOWN_STOP_ADVERTISING_ERROR;
-constexpr int StopAdvertisingError_ARRAYSIZE = StopAdvertisingError_MAX + 1;

-const std::string& StopAdvertisingError_Name(StopAdvertisingError value);
-template<typename T>
-inline const std::string& StopAdvertisingError_Name(T enum_t_value) {
+extern const uint32_t StopAdvertisingError_internal_data_[];
+inline constexpr StopAdvertisingError StopAdvertisingError_MIN =
+    static_cast<StopAdvertisingError>(31);
+inline constexpr StopAdvertisingError StopAdvertisingError_MAX =
+    static_cast<StopAdvertisingError>(35);
+inline bool StopAdvertisingError_IsValid(int value) {
+  return 31 <= value && value <= 35;
+}
+inline constexpr int StopAdvertisingError_ARRAYSIZE = 35 + 1;
+const ::std::string& StopAdvertisingError_Name(StopAdvertisingError value);
+template <typename T>
+const ::std::string& StopAdvertisingError_Name(T value) {
  static_assert(::std::is_same<T, StopAdvertisingError>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function StopAdvertisingError_Name.");
-  return StopAdvertisingError_Name(static_cast<StopAdvertisingError>(enum_t_value));
+                    ::std::is_integral<T>::value,
+                "Incorrect type passed to StopAdvertisingError_Name().");
+  return StopAdvertisingError_Name(static_cast<StopAdvertisingError>(value));
 }
 bool StopAdvertisingError_Parse(
-    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StopAdvertisingError* value);
+    ::absl::string_view name, StopAdvertisingError* PROTOBUF_NONNULL value);
 enum StartDiscoveringError : int {
  DUPLICATE_DISCOVERING_REQUESTED = 31,
  START_LEGACY_DISCOVERING_FAILED = 32,
@@ -201,44 +317,54 @@ enum StartDiscoveringError : int {
  L2CAP_FETCH_ADVERTISEMENT_FAILED = 38,
  NOT_AVAILABLE_TO_FETCH_ADVERTISEMENT = 39,
  ACQUIRE_WIFI_AWARE_SESSION_FOR_DISCOVERING_FAILED = 40,
-  UNKNOWN_START_DISCOVERING_ERROR = 41
+  UNKNOWN_START_DISCOVERING_ERROR = 41,
 };
-bool StartDiscoveringError_IsValid(int value);
-constexpr StartDiscoveringError StartDiscoveringError_MIN = DUPLICATE_DISCOVERING_REQUESTED;
-constexpr StartDiscoveringError StartDiscoveringError_MAX = UNKNOWN_START_DISCOVERING_ERROR;
-constexpr int StartDiscoveringError_ARRAYSIZE = StartDiscoveringError_MAX + 1;

-const std::string& StartDiscoveringError_Name(StartDiscoveringError value);
-template<typename T>
-inline const std::string& StartDiscoveringError_Name(T enum_t_value) {
+extern const uint32_t StartDiscoveringError_internal_data_[];
+inline constexpr StartDiscoveringError StartDiscoveringError_MIN =
+    static_cast<StartDiscoveringError>(31);
+inline constexpr StartDiscoveringError StartDiscoveringError_MAX =
+    static_cast<StartDiscoveringError>(41);
+inline bool StartDiscoveringError_IsValid(int value) {
+  return 31 <= value && value <= 41;
+}
+inline constexpr int StartDiscoveringError_ARRAYSIZE = 41 + 1;
+const ::std::string& StartDiscoveringError_Name(StartDiscoveringError value);
+template <typename T>
+const ::std::string& StartDiscoveringError_Name(T value) {
  static_assert(::std::is_same<T, StartDiscoveringError>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function StartDiscoveringError_Name.");
-  return StartDiscoveringError_Name(static_cast<StartDiscoveringError>(enum_t_value));
+                    ::std::is_integral<T>::value,
+                "Incorrect type passed to StartDiscoveringError_Name().");
+  return StartDiscoveringError_Name(static_cast<StartDiscoveringError>(value));
 }
 bool StartDiscoveringError_Parse(
-    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StartDiscoveringError* value);
+    ::absl::string_view name, StartDiscoveringError* PROTOBUF_NONNULL value);
 enum StopDiscoveringError : int {
  STOP_DISCOVERING_FAILED = 31,
  STOP_LEGACY_DISCOVERING_FAILED = 32,
  STOP_EXTENDED_DISCOVERING_FAILED = 33,
-  UNKNOWN_STOP_DISCOVERING_ERROR = 34
+  UNKNOWN_STOP_DISCOVERING_ERROR = 34,
 };
-bool StopDiscoveringError_IsValid(int value);
-constexpr StopDiscoveringError StopDiscoveringError_MIN = STOP_DISCOVERING_FAILED;
-constexpr StopDiscoveringError StopDiscoveringError_MAX = UNKNOWN_STOP_DISCOVERING_ERROR;
-constexpr int StopDiscoveringError_ARRAYSIZE = StopDiscoveringError_MAX + 1;

-const std::string& StopDiscoveringError_Name(StopDiscoveringError value);
-template<typename T>
-inline const std::string& StopDiscoveringError_Name(T enum_t_value) {
+extern const uint32_t StopDiscoveringError_internal_data_[];
+inline constexpr StopDiscoveringError StopDiscoveringError_MIN =
+    static_cast<StopDiscoveringError>(31);
+inline constexpr StopDiscoveringError StopDiscoveringError_MAX =
+    static_cast<StopDiscoveringError>(34);
+inline bool StopDiscoveringError_IsValid(int value) {
+  return 31 <= value && value <= 34;
+}
+inline constexpr int StopDiscoveringError_ARRAYSIZE = 34 + 1;
+const ::std::string& StopDiscoveringError_Name(StopDiscoveringError value);
+template <typename T>
+const ::std::string& StopDiscoveringError_Name(T value) {
  static_assert(::std::is_same<T, StopDiscoveringError>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function StopDiscoveringError_Name.");
-  return StopDiscoveringError_Name(static_cast<StopDiscoveringError>(enum_t_value));
+                    ::std::is_integral<T>::value,
+                "Incorrect type passed to StopDiscoveringError_Name().");
+  return StopDiscoveringError_Name(static_cast<StopDiscoveringError>(value));
 }
 bool StopDiscoveringError_Parse(
-    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StopDiscoveringError* value);
+    ::absl::string_view name, StopDiscoveringError* PROTOBUF_NONNULL value);
 enum StartListeningIncomingConnectionError : int {
  DUPLICATE_ACCEPTING_CONNECTION_REQUESTED = 31,
  OPEN_GATT_SERVER_FAILED = 32,
@@ -249,42 +375,52 @@ enum StartListeningIncomingConnectionError : int {
  CREATE_SERVER_SOCKET_FAILED = 37,
  UNKNOWN_START_LISTENING_INCOMING_CONNECTION_ERROR = 38,
  ACCEPT_SEND_AWARE_L2_MESSAGE_FAILED = 39,
-  ACCEPT_RECEIVE_AWARE_L2_MESSAGE_FAILED = 40
+  ACCEPT_RECEIVE_AWARE_L2_MESSAGE_FAILED = 40,
 };
-bool StartListeningIncomingConnectionError_IsValid(int value);
-constexpr StartListeningIncomingConnectionError StartListeningIncomingConnectionError_MIN = DUPLICATE_ACCEPTING_CONNECTION_REQUESTED;
-constexpr StartListeningIncomingConnectionError StartListeningIncomingConnectionError_MAX = ACCEPT_RECEIVE_AWARE_L2_MESSAGE_FAILED;
-constexpr int StartListeningIncomingConnectionError_ARRAYSIZE = StartListeningIncomingConnectionError_MAX + 1;

-const std::string& StartListeningIncomingConnectionError_Name(StartListeningIncomingConnectionError value);
-template<typename T>
-inline const std::string& StartListeningIncomingConnectionError_Name(T enum_t_value) {
+extern const uint32_t StartListeningIncomingConnectionError_internal_data_[];
+inline constexpr StartListeningIncomingConnectionError StartListeningIncomingConnectionError_MIN =
+    static_cast<StartListeningIncomingConnectionError>(31);
+inline constexpr StartListeningIncomingConnectionError StartListeningIncomingConnectionError_MAX =
+    static_cast<StartListeningIncomingConnectionError>(40);
+inline bool StartListeningIncomingConnectionError_IsValid(int value) {
+  return 31 <= value && value <= 40;
+}
+inline constexpr int StartListeningIncomingConnectionError_ARRAYSIZE = 40 + 1;
+const ::std::string& StartListeningIncomingConnectionError_Name(StartListeningIncomingConnectionError value);
+template <typename T>
+const ::std::string& StartListeningIncomingConnectionError_Name(T value) {
  static_assert(::std::is_same<T, StartListeningIncomingConnectionError>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function StartListeningIncomingConnectionError_Name.");
-  return StartListeningIncomingConnectionError_Name(static_cast<StartListeningIncomingConnectionError>(enum_t_value));
+                    ::std::is_integral<T>::value,
+                "Incorrect type passed to StartListeningIncomingConnectionError_Name().");
+  return StartListeningIncomingConnectionError_Name(static_cast<StartListeningIncomingConnectionError>(value));
 }
 bool StartListeningIncomingConnectionError_Parse(
-    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StartListeningIncomingConnectionError* value);
+    ::absl::string_view name, StartListeningIncomingConnectionError* PROTOBUF_NONNULL value);
 enum StopListeningIncomingConnectionError : int {
  STOP_ACCEPTING_CONNECTION_FAILED = 31,
-  UNKNOWN_STOP_LISTENING_INCOMING_CONNECTION_ERROR = 32
+  UNKNOWN_STOP_LISTENING_INCOMING_CONNECTION_ERROR = 32,
 };
-bool StopListeningIncomingConnectionError_IsValid(int value);
-constexpr StopListeningIncomingConnectionError StopListeningIncomingConnectionError_MIN = STOP_ACCEPTING_CONNECTION_FAILED;
-constexpr StopListeningIncomingConnectionError StopListeningIncomingConnectionError_MAX = UNKNOWN_STOP_LISTENING_INCOMING_CONNECTION_ERROR;
-constexpr int StopListeningIncomingConnectionError_ARRAYSIZE = StopListeningIncomingConnectionError_MAX + 1;

-const std::string& StopListeningIncomingConnectionError_Name(StopListeningIncomingConnectionError value);
-template<typename T>
-inline const std::string& StopListeningIncomingConnectionError_Name(T enum_t_value) {
+extern const uint32_t StopListeningIncomingConnectionError_internal_data_[];
+inline constexpr StopListeningIncomingConnectionError StopListeningIncomingConnectionError_MIN =
+    static_cast<StopListeningIncomingConnectionError>(31);
+inline constexpr StopListeningIncomingConnectionError StopListeningIncomingConnectionError_MAX =
+    static_cast<StopListeningIncomingConnectionError>(32);
+inline bool StopListeningIncomingConnectionError_IsValid(int value) {
+  return 31 <= value && value <= 32;
+}
+inline constexpr int StopListeningIncomingConnectionError_ARRAYSIZE = 32 + 1;
+const ::std::string& StopListeningIncomingConnectionError_Name(StopListeningIncomingConnectionError value);
+template <typename T>
+const ::std::string& StopListeningIncomingConnectionError_Name(T value) {
  static_assert(::std::is_same<T, StopListeningIncomingConnectionError>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function StopListeningIncomingConnectionError_Name.");
-  return StopListeningIncomingConnectionError_Name(static_cast<StopListeningIncomingConnectionError>(enum_t_value));
+                    ::std::is_integral<T>::value,
+                "Incorrect type passed to StopListeningIncomingConnectionError_Name().");
+  return StopListeningIncomingConnectionError_Name(static_cast<StopListeningIncomingConnectionError>(value));
 }
 bool StopListeningIncomingConnectionError_Parse(
-    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StopListeningIncomingConnectionError* value);
+    ::absl::string_view name, StopListeningIncomingConnectionError* PROTOBUF_NONNULL value);
 enum ConnectError : int {
  UNEXPECT_TARGET_LOST = 31,
  ESTABLISH_GATT_CONNECTION_FAILED = 32,
@@ -301,137 +437,172 @@ enum ConnectError : int {
  CONNECT_TO_NETWORK_FAILED = 43,
  UNKNOWN_CONNECT_ERROR = 44,
  CONNECT_SEND_AWARE_L2_MESSAGE_FAILED = 45,
-  CONNECT_READ_AWARE_L2_MESSAGE_FAILED = 46
+  CONNECT_READ_AWARE_L2_MESSAGE_FAILED = 46,
 };
-bool ConnectError_IsValid(int value);
-constexpr ConnectError ConnectError_MIN = UNEXPECT_TARGET_LOST;
-constexpr ConnectError ConnectError_MAX = CONNECT_READ_AWARE_L2_MESSAGE_FAILED;
-constexpr int ConnectError_ARRAYSIZE = ConnectError_MAX + 1;

-const std::string& ConnectError_Name(ConnectError value);
-template<typename T>
-inline const std::string& ConnectError_Name(T enum_t_value) {
+extern const uint32_t ConnectError_internal_data_[];
+inline constexpr ConnectError ConnectError_MIN =
+    static_cast<ConnectError>(31);
+inline constexpr ConnectError ConnectError_MAX =
+    static_cast<ConnectError>(46);
+inline bool ConnectError_IsValid(int value) {
+  return 31 <= value && value <= 46;
+}
+inline constexpr int ConnectError_ARRAYSIZE = 46 + 1;
+const ::std::string& ConnectError_Name(ConnectError value);
+template <typename T>
+const ::std::string& ConnectError_Name(T value) {
  static_assert(::std::is_same<T, ConnectError>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function ConnectError_Name.");
-  return ConnectError_Name(static_cast<ConnectError>(enum_t_value));
+                    ::std::is_integral<T>::value,
+                "Incorrect type passed to ConnectError_Name().");
+  return ConnectError_Name(static_cast<ConnectError>(value));
 }
 bool ConnectError_Parse(
-    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConnectError* value);
+    ::absl::string_view name, ConnectError* PROTOBUF_NONNULL value);
 enum DisconnectError : int {
  DISCONNECT_NETWORK_FAILED = 31,
-  UNKNOWN_DISCONNECT_ERROR = 32
+  UNKNOWN_DISCONNECT_ERROR = 32,
 };
-bool DisconnectError_IsValid(int value);
-constexpr DisconnectError DisconnectError_MIN = DISCONNECT_NETWORK_FAILED;
-constexpr DisconnectError DisconnectError_MAX = UNKNOWN_DISCONNECT_ERROR;
-constexpr int DisconnectError_ARRAYSIZE = DisconnectError_MAX + 1;

-const std::string& DisconnectError_Name(DisconnectError value);
-template<typename T>
-inline const std::string& DisconnectError_Name(T enum_t_value) {
+extern const uint32_t DisconnectError_internal_data_[];
+inline constexpr DisconnectError DisconnectError_MIN =
+    static_cast<DisconnectError>(31);
+inline constexpr DisconnectError DisconnectError_MAX =
+    static_cast<DisconnectError>(32);
+inline bool DisconnectError_IsValid(int value) {
+  return 31 <= value && value <= 32;
+}
+inline constexpr int DisconnectError_ARRAYSIZE = 32 + 1;
+const ::std::string& DisconnectError_Name(DisconnectError value);
+template <typename T>
+const ::std::string& DisconnectError_Name(T value) {
  static_assert(::std::is_same<T, DisconnectError>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function DisconnectError_Name.");
-  return DisconnectError_Name(static_cast<DisconnectError>(enum_t_value));
+                    ::std::is_integral<T>::value,
+                "Incorrect type passed to DisconnectError_Name().");
+  return DisconnectError_Name(static_cast<DisconnectError>(value));
 }
 bool DisconnectError_Parse(
-    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DisconnectError* value);
+    ::absl::string_view name, DisconnectError* PROTOBUF_NONNULL value);
 enum SendPayloadError : int {
  UNKNOWN_SEND_PAYLOAD_ERROR = 31,
-  SEND_PAYLOAD_FAILED = 32
+  SEND_PAYLOAD_FAILED = 32,
 };
-bool SendPayloadError_IsValid(int value);
-constexpr SendPayloadError SendPayloadError_MIN = UNKNOWN_SEND_PAYLOAD_ERROR;
-constexpr SendPayloadError SendPayloadError_MAX = SEND_PAYLOAD_FAILED;
-constexpr int SendPayloadError_ARRAYSIZE = SendPayloadError_MAX + 1;

-const std::string& SendPayloadError_Name(SendPayloadError value);
-template<typename T>
-inline const std::string& SendPayloadError_Name(T enum_t_value) {
+extern const uint32_t SendPayloadError_internal_data_[];
+inline constexpr SendPayloadError SendPayloadError_MIN =
+    static_cast<SendPayloadError>(31);
+inline constexpr SendPayloadError SendPayloadError_MAX =
+    static_cast<SendPayloadError>(32);
+inline bool SendPayloadError_IsValid(int value) {
+  return 31 <= value && value <= 32;
+}
+inline constexpr int SendPayloadError_ARRAYSIZE = 32 + 1;
+const ::std::string& SendPayloadError_Name(SendPayloadError value);
+template <typename T>
+const ::std::string& SendPayloadError_Name(T value) {
  static_assert(::std::is_same<T, SendPayloadError>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function SendPayloadError_Name.");
-  return SendPayloadError_Name(static_cast<SendPayloadError>(enum_t_value));
+                    ::std::is_integral<T>::value,
+                "Incorrect type passed to SendPayloadError_Name().");
+  return SendPayloadError_Name(static_cast<SendPayloadError>(value));
 }
 bool SendPayloadError_Parse(
-    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SendPayloadError* value);
+    ::absl::string_view name, SendPayloadError* PROTOBUF_NONNULL value);
 enum ReceivePayloadError : int {
  UNKNOWN_RECEIVE_PAYLOAD_ERROR = 31,
-  RECEIVE_PAYLOAD_FAILED = 32
+  RECEIVE_PAYLOAD_FAILED = 32,
 };
-bool ReceivePayloadError_IsValid(int value);
-constexpr ReceivePayloadError ReceivePayloadError_MIN = UNKNOWN_RECEIVE_PAYLOAD_ERROR;
-constexpr ReceivePayloadError ReceivePayloadError_MAX = RECEIVE_PAYLOAD_FAILED;
-constexpr int ReceivePayloadError_ARRAYSIZE = ReceivePayloadError_MAX + 1;

-const std::string& ReceivePayloadError_Name(ReceivePayloadError value);
-template<typename T>
-inline const std::string& ReceivePayloadError_Name(T enum_t_value) {
+extern const uint32_t ReceivePayloadError_internal_data_[];
+inline constexpr ReceivePayloadError ReceivePayloadError_MIN =
+    static_cast<ReceivePayloadError>(31);
+inline constexpr ReceivePayloadError ReceivePayloadError_MAX =
+    static_cast<ReceivePayloadError>(32);
+inline bool ReceivePayloadError_IsValid(int value) {
+  return 31 <= value && value <= 32;
+}
+inline constexpr int ReceivePayloadError_ARRAYSIZE = 32 + 1;
+const ::std::string& ReceivePayloadError_Name(ReceivePayloadError value);
+template <typename T>
+const ::std::string& ReceivePayloadError_Name(T value) {
  static_assert(::std::is_same<T, ReceivePayloadError>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function ReceivePayloadError_Name.");
-  return ReceivePayloadError_Name(static_cast<ReceivePayloadError>(enum_t_value));
+                    ::std::is_integral<T>::value,
+                "Incorrect type passed to ReceivePayloadError_Name().");
+  return ReceivePayloadError_Name(static_cast<ReceivePayloadError>(value));
 }
 bool ReceivePayloadError_Parse(
-    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ReceivePayloadError* value);
+    ::absl::string_view name, ReceivePayloadError* PROTOBUF_NONNULL value);
 enum UpgradeError : int {
  UNKNOWN_UPGRADE_ERROR = 31,
-  CREATE_P2P_GROUP_FAILED = 32
+  CREATE_P2P_GROUP_FAILED = 32,
 };
-bool UpgradeError_IsValid(int value);
-constexpr UpgradeError UpgradeError_MIN = UNKNOWN_UPGRADE_ERROR;
-constexpr UpgradeError UpgradeError_MAX = CREATE_P2P_GROUP_FAILED;
-constexpr int UpgradeError_ARRAYSIZE = UpgradeError_MAX + 1;

-const std::string& UpgradeError_Name(UpgradeError value);
-template<typename T>
-inline const std::string& UpgradeError_Name(T enum_t_value) {
+extern const uint32_t UpgradeError_internal_data_[];
+inline constexpr UpgradeError UpgradeError_MIN =
+    static_cast<UpgradeError>(31);
+inline constexpr UpgradeError UpgradeError_MAX =
+    static_cast<UpgradeError>(32);
+inline bool UpgradeError_IsValid(int value) {
+  return 31 <= value && value <= 32;
+}
+inline constexpr int UpgradeError_ARRAYSIZE = 32 + 1;
+const ::std::string& UpgradeError_Name(UpgradeError value);
+template <typename T>
+const ::std::string& UpgradeError_Name(T value) {
  static_assert(::std::is_same<T, UpgradeError>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function UpgradeError_Name.");
-  return UpgradeError_Name(static_cast<UpgradeError>(enum_t_value));
+                    ::std::is_integral<T>::value,
+                "Incorrect type passed to UpgradeError_Name().");
+  return UpgradeError_Name(static_cast<UpgradeError>(value));
 }
 bool UpgradeError_Parse(
-    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, UpgradeError* value);
+    ::absl::string_view name, UpgradeError* PROTOBUF_NONNULL value);
 enum AcceptConnectionError : int {
  UNKNOWN_ACCEPT_CONNECTION_ERROR = 31,
-  RESPOND_ACCEPT_CONNECTION_FAILED = 32
+  RESPOND_ACCEPT_CONNECTION_FAILED = 32,
 };
-bool AcceptConnectionError_IsValid(int value);
-constexpr AcceptConnectionError AcceptConnectionError_MIN = UNKNOWN_ACCEPT_CONNECTION_ERROR;
-constexpr AcceptConnectionError AcceptConnectionError_MAX = RESPOND_ACCEPT_CONNECTION_FAILED;
-constexpr int AcceptConnectionError_ARRAYSIZE = AcceptConnectionError_MAX + 1;

-const std::string& AcceptConnectionError_Name(AcceptConnectionError value);
-template<typename T>
-inline const std::string& AcceptConnectionError_Name(T enum_t_value) {
+extern const uint32_t AcceptConnectionError_internal_data_[];
+inline constexpr AcceptConnectionError AcceptConnectionError_MIN =
+    static_cast<AcceptConnectionError>(31);
+inline constexpr AcceptConnectionError AcceptConnectionError_MAX =
+    static_cast<AcceptConnectionError>(32);
+inline bool AcceptConnectionError_IsValid(int value) {
+  return 31 <= value && value <= 32;
+}
+inline constexpr int AcceptConnectionError_ARRAYSIZE = 32 + 1;
+const ::std::string& AcceptConnectionError_Name(AcceptConnectionError value);
+template <typename T>
+const ::std::string& AcceptConnectionError_Name(T value) {
  static_assert(::std::is_same<T, AcceptConnectionError>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function AcceptConnectionError_Name.");
-  return AcceptConnectionError_Name(static_cast<AcceptConnectionError>(enum_t_value));
+                    ::std::is_integral<T>::value,
+                "Incorrect type passed to AcceptConnectionError_Name().");
+  return AcceptConnectionError_Name(static_cast<AcceptConnectionError>(value));
 }
 bool AcceptConnectionError_Parse(
-    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AcceptConnectionError* value);
+    ::absl::string_view name, AcceptConnectionError* PROTOBUF_NONNULL value);
 enum RejectConnectionError : int {
  UNKNOWN_REJECT_CONNECTION_ERROR = 31,
-  RESPOND_REJECT_CONNECTION_FAILED = 32
+  RESPOND_REJECT_CONNECTION_FAILED = 32,
 };
-bool RejectConnectionError_IsValid(int value);
-constexpr RejectConnectionError RejectConnectionError_MIN = UNKNOWN_REJECT_CONNECTION_ERROR;
-constexpr RejectConnectionError RejectConnectionError_MAX = RESPOND_REJECT_CONNECTION_FAILED;
-constexpr int RejectConnectionError_ARRAYSIZE = RejectConnectionError_MAX + 1;

-const std::string& RejectConnectionError_Name(RejectConnectionError value);
-template<typename T>
-inline const std::string& RejectConnectionError_Name(T enum_t_value) {
+extern const uint32_t RejectConnectionError_internal_data_[];
+inline constexpr RejectConnectionError RejectConnectionError_MIN =
+    static_cast<RejectConnectionError>(31);
+inline constexpr RejectConnectionError RejectConnectionError_MAX =
+    static_cast<RejectConnectionError>(32);
+inline bool RejectConnectionError_IsValid(int value) {
+  return 31 <= value && value <= 32;
+}
+inline constexpr int RejectConnectionError_ARRAYSIZE = 32 + 1;
+const ::std::string& RejectConnectionError_Name(RejectConnectionError value);
+template <typename T>
+const ::std::string& RejectConnectionError_Name(T value) {
  static_assert(::std::is_same<T, RejectConnectionError>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function RejectConnectionError_Name.");
-  return RejectConnectionError_Name(static_cast<RejectConnectionError>(enum_t_value));
+                    ::std::is_integral<T>::value,
+                "Incorrect type passed to RejectConnectionError_Name().");
+  return RejectConnectionError_Name(static_cast<RejectConnectionError>(value));
 }
 bool RejectConnectionError_Parse(
-    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, RejectConnectionError* value);
+    ::absl::string_view name, RejectConnectionError* PROTOBUF_NONNULL value);
 enum Description : int {
  UNKNOWN = 0,
  NULL_SERVICE_ID = 1,
@@ -618,69 +789,99 @@ enum Description : int {
  MULTIPLEX_SOCKET_IOEXCEPTION = 184,
  MULTIPLEX_SOCKET_UNKNOWN_RESPONSE_CODE = 185,
  MULTIPLEX_SOCKET_EXECUTION_EXCEPTION = 186,
-  MULTIPLEX_SOCKET_INTERRUPTED_EXCEPTION = 187
+  MULTIPLEX_SOCKET_INTERRUPTED_EXCEPTION = 187,
 };
-bool Description_IsValid(int value);
-constexpr Description Description_MIN = UNKNOWN;
-constexpr Description Description_MAX = MULTIPLEX_SOCKET_INTERRUPTED_EXCEPTION;
-constexpr int Description_ARRAYSIZE = Description_MAX + 1;

-const std::string& Description_Name(Description value);
-template<typename T>
-inline const std::string& Description_Name(T enum_t_value) {
+extern const uint32_t Description_internal_data_[];
+inline constexpr Description Description_MIN =
+    static_cast<Description>(0);
+inline constexpr Description Description_MAX =
+    static_cast<Description>(187);
+inline bool Description_IsValid(int value) {
+  return ::google::protobuf::internal::ValidateEnum(value, Description_internal_data_);
+}
+inline constexpr int Description_ARRAYSIZE = 187 + 1;
+const ::std::string& Description_Name(Description value);
+template <typename T>
+const ::std::string& Description_Name(T value) {
  static_assert(::std::is_same<T, Description>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function Description_Name.");
-  return Description_Name(static_cast<Description>(enum_t_value));
+                    ::std::is_integral<T>::value,
+                "Incorrect type passed to Description_Name().");
+  return Description_Name(static_cast<Description>(value));
 }
 bool Description_Parse(
-    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Description* value);
+    ::absl::string_view name, Description* PROTOBUF_NONNULL value);
+
 // ===================================================================


+
 // ===================================================================


+
+
 // ===================================================================

+
 #ifdef __GNUC__
-  #pragma GCC diagnostic push
-  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
 #endif  // __GNUC__
 #ifdef __GNUC__
-  #pragma GCC diagnostic pop
+#pragma GCC diagnostic pop
 #endif  // __GNUC__

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

-PROTOBUF_NAMESPACE_OPEN

-template <> struct is_proto_enum< ::location::nearby::errorcode::proto::ErrorType> : ::std::true_type {};
-template <> struct is_proto_enum< ::location::nearby::errorcode::proto::Event> : ::std::true_type {};
-template <> struct is_proto_enum< ::location::nearby::errorcode::proto::CommonError> : ::std::true_type {};
-template <> struct is_proto_enum< ::location::nearby::errorcode::proto::StartAdvertisingError> : ::std::true_type {};
-template <> struct is_proto_enum< ::location::nearby::errorcode::proto::StopAdvertisingError> : ::std::true_type {};
-template <> struct is_proto_enum< ::location::nearby::errorcode::proto::StartDiscoveringError> : ::std::true_type {};
-template <> struct is_proto_enum< ::location::nearby::errorcode::proto::StopDiscoveringError> : ::std::true_type {};
-template <> struct is_proto_enum< ::location::nearby::errorcode::proto::StartListeningIncomingConnectionError> : ::std::true_type {};
-template <> struct is_proto_enum< ::location::nearby::errorcode::proto::StopListeningIncomingConnectionError> : ::std::true_type {};
-template <> struct is_proto_enum< ::location::nearby::errorcode::proto::ConnectError> : ::std::true_type {};
-template <> struct is_proto_enum< ::location::nearby::errorcode::proto::DisconnectError> : ::std::true_type {};
-template <> struct is_proto_enum< ::location::nearby::errorcode::proto::SendPayloadError> : ::std::true_type {};
-template <> struct is_proto_enum< ::location::nearby::errorcode::proto::ReceivePayloadError> : ::std::true_type {};
-template <> struct is_proto_enum< ::location::nearby::errorcode::proto::UpgradeError> : ::std::true_type {};
-template <> struct is_proto_enum< ::location::nearby::errorcode::proto::AcceptConnectionError> : ::std::true_type {};
-template <> struct is_proto_enum< ::location::nearby::errorcode::proto::RejectConnectionError> : ::std::true_type {};
-template <> struct is_proto_enum< ::location::nearby::errorcode::proto::Description> : ::std::true_type {};
+namespace google {
+namespace protobuf {

-PROTOBUF_NAMESPACE_CLOSE
+template <>
+struct is_proto_enum<::location::nearby::errorcode::proto::ErrorType> : std::true_type {};
+template <>
+struct is_proto_enum<::location::nearby::errorcode::proto::Event> : std::true_type {};
+template <>
+struct is_proto_enum<::location::nearby::errorcode::proto::CommonError> : std::true_type {};
+template <>
+struct is_proto_enum<::location::nearby::errorcode::proto::StartAdvertisingError> : std::true_type {};
+template <>
+struct is_proto_enum<::location::nearby::errorcode::proto::StopAdvertisingError> : std::true_type {};
+template <>
+struct is_proto_enum<::location::nearby::errorcode::proto::StartDiscoveringError> : std::true_type {};
+template <>
+struct is_proto_enum<::location::nearby::errorcode::proto::StopDiscoveringError> : std::true_type {};
+template <>
+struct is_proto_enum<::location::nearby::errorcode::proto::StartListeningIncomingConnectionError> : std::true_type {};
+template <>
+struct is_proto_enum<::location::nearby::errorcode::proto::StopListeningIncomingConnectionError> : std::true_type {};
+template <>
+struct is_proto_enum<::location::nearby::errorcode::proto::ConnectError> : std::true_type {};
+template <>
+struct is_proto_enum<::location::nearby::errorcode::proto::DisconnectError> : std::true_type {};
+template <>
+struct is_proto_enum<::location::nearby::errorcode::proto::SendPayloadError> : std::true_type {};
+template <>
+struct is_proto_enum<::location::nearby::errorcode::proto::ReceivePayloadError> : std::true_type {};
+template <>
+struct is_proto_enum<::location::nearby::errorcode::proto::UpgradeError> : std::true_type {};
+template <>
+struct is_proto_enum<::location::nearby::errorcode::proto::AcceptConnectionError> : std::true_type {};
+template <>
+struct is_proto_enum<::location::nearby::errorcode::proto::RejectConnectionError> : std::true_type {};
+template <>
+struct is_proto_enum<::location::nearby::errorcode::proto::Description> : std::true_type {};
+
+}  // namespace protobuf
+}  // namespace google

 // @@protoc_insertion_point(global_scope)

-#include <google/protobuf/port_undef.inc>
-#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_proto_2ferrorcode_2ferror_5fcode_5fenums_2eproto
+#include "google/protobuf/port_undef.inc"
+
+#endif  // proto_2ferrorcode_2ferror_5fcode_5fenums_2eproto_2epb_2eh