diff --git a/compiled_proto/internal/proto/analytics/connections_log.pb.cc b/compiled_proto/internal/proto/analytics/connections_log.pb.cc
index 2167e5a6..e907b024 100644
--- a/compiled_proto/internal/proto/analytics/connections_log.pb.cc
+++ b/compiled_proto/internal/proto/analytics/connections_log.pb.cc
@@ -32,6 +32,21 @@ struct ConnectionsLog_ClientSessionDefaultTypeInternal {
   };
 };
 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ConnectionsLog_ClientSessionDefaultTypeInternal _ConnectionsLog_ClientSession_default_instance_;
+constexpr ConnectionsLog_OperationResult::ConnectionsLog_OperationResult(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : result_category_(0)
+
+  , result_code_(0)
+{}
+struct ConnectionsLog_OperationResultDefaultTypeInternal {
+  constexpr ConnectionsLog_OperationResultDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~ConnectionsLog_OperationResultDefaultTypeInternal() {}
+  union {
+    ConnectionsLog_OperationResult _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ConnectionsLog_OperationResultDefaultTypeInternal _ConnectionsLog_OperationResult_default_instance_;
 constexpr ConnectionsLog_StrategySession::ConnectionsLog_StrategySession(
   ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
   : role_()
@@ -159,6 +174,7 @@ constexpr ConnectionsLog_ConnectionAttempt::ConnectionsLog_ConnectionAttempt(
   ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
   : connection_token_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
   , connection_attempt_metadata_(nullptr)
+  , operation_result_(nullptr)
   , duration_millis_(int64_t{0})
   , type_(0)
 
@@ -183,6 +199,7 @@ constexpr ConnectionsLog_EstablishedConnection::ConnectionsLog_EstablishedConnec
   : sent_payload_()
   , received_payload_()
   , connection_token_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+  , operation_result_(nullptr)
   , duration_millis_(int64_t{0})
   , medium_(0)
 
@@ -204,7 +221,8 @@ struct ConnectionsLog_EstablishedConnectionDefaultTypeInternal {
 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ConnectionsLog_EstablishedConnectionDefaultTypeInternal _ConnectionsLog_EstablishedConnection_default_instance_;
 constexpr ConnectionsLog_Payload::ConnectionsLog_Payload(
   ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
-  : duration_millis_(int64_t{0})
+  : operation_result_(nullptr)
+  , duration_millis_(int64_t{0})
   , total_size_bytes_(int64_t{0})
   , type_(0)
 
@@ -225,6 +243,7 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ConnectionsLog_PayloadDefaultTy
 constexpr ConnectionsLog_BandwidthUpgradeAttempt::ConnectionsLog_BandwidthUpgradeAttempt(
   ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
   : connection_token_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+  , operation_result_(nullptr)
   , duration_millis_(int64_t{0})
   , direction_(0)
 
@@ -740,6 +759,252 @@ std::string ConnectionsLog_ClientSession::GetTypeName() const {
 }
 
 
+// ===================================================================
+
+class ConnectionsLog_OperationResult::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ConnectionsLog_OperationResult>()._has_bits_);
+  static void set_has_result_category(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_result_code(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+ConnectionsLog_OperationResult::ConnectionsLog_OperationResult(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:location.nearby.analytics.proto.ConnectionsLog.OperationResult)
+}
+ConnectionsLog_OperationResult::ConnectionsLog_OperationResult(const ConnectionsLog_OperationResult& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
+      _has_bits_(from._has_bits_) {
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  ::memcpy(&result_category_, &from.result_category_,
+    static_cast<size_t>(reinterpret_cast<char*>(&result_code_) -
+    reinterpret_cast<char*>(&result_category_)) + sizeof(result_code_));
+  // @@protoc_insertion_point(copy_constructor:location.nearby.analytics.proto.ConnectionsLog.OperationResult)
+}
+
+inline void ConnectionsLog_OperationResult::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&result_category_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&result_code_) -
+    reinterpret_cast<char*>(&result_category_)) + sizeof(result_code_));
+}
+
+ConnectionsLog_OperationResult::~ConnectionsLog_OperationResult() {
+  // @@protoc_insertion_point(destructor:location.nearby.analytics.proto.ConnectionsLog.OperationResult)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<std::string>();
+}
+
+inline void ConnectionsLog_OperationResult::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void ConnectionsLog_OperationResult::ArenaDtor(void* object) {
+  ConnectionsLog_OperationResult* _this = reinterpret_cast< ConnectionsLog_OperationResult* >(object);
+  (void)_this;
+}
+void ConnectionsLog_OperationResult::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void ConnectionsLog_OperationResult::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void ConnectionsLog_OperationResult::Clear() {
+// @@protoc_insertion_point(message_clear_start:location.nearby.analytics.proto.ConnectionsLog.OperationResult)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    ::memset(&result_category_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&result_code_) -
+        reinterpret_cast<char*>(&result_category_)) + sizeof(result_code_));
+  }
+  _has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ConnectionsLog_OperationResult::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .location.nearby.proto.connections.OperationResultCategory result_category = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::location::nearby::proto::connections::OperationResultCategory_IsValid(val))) {
+            _internal_set_result_category(static_cast<::location::nearby::proto::connections::OperationResultCategory>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .location.nearby.proto.connections.OperationResultCode result_code = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::location::nearby::proto::connections::OperationResultCode_IsValid(val))) {
+            _internal_set_result_code(static_cast<::location::nearby::proto::connections::OperationResultCode>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ConnectionsLog_OperationResult::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:location.nearby.analytics.proto.ConnectionsLog.OperationResult)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  // optional .location.nearby.proto.connections.OperationResultCategory result_category = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      1, this->_internal_result_category(), target);
+  }
+
+  // optional .location.nearby.proto.connections.OperationResultCode result_code = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_result_code(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:location.nearby.analytics.proto.ConnectionsLog.OperationResult)
+  return target;
+}
+
+size_t ConnectionsLog_OperationResult::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:location.nearby.analytics.proto.ConnectionsLog.OperationResult)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional .location.nearby.proto.connections.OperationResultCategory result_category = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_result_category());
+    }
+
+    // optional .location.nearby.proto.connections.OperationResultCode result_code = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_result_code());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ConnectionsLog_OperationResult::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ConnectionsLog_OperationResult*>(
+      &from));
+}
+
+void ConnectionsLog_OperationResult::MergeFrom(const ConnectionsLog_OperationResult& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.analytics.proto.ConnectionsLog.OperationResult)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      result_category_ = from.result_category_;
+    }
+    if (cached_has_bits & 0x00000002u) {
+      result_code_ = from.result_code_;
+    }
+    _has_bits_[0] |= cached_has_bits;
+  }
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ConnectionsLog_OperationResult::CopyFrom(const ConnectionsLog_OperationResult& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.analytics.proto.ConnectionsLog.OperationResult)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ConnectionsLog_OperationResult::IsInitialized() const {
+  return true;
+}
+
+void ConnectionsLog_OperationResult::InternalSwap(ConnectionsLog_OperationResult* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_has_bits_[0], other->_has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ConnectionsLog_OperationResult, result_code_)
+      + sizeof(ConnectionsLog_OperationResult::result_code_)
+      - PROTOBUF_FIELD_OFFSET(ConnectionsLog_OperationResult, result_category_)>(
+          reinterpret_cast<char*>(&result_category_),
+          reinterpret_cast<char*>(&other->result_category_));
+}
+
+std::string ConnectionsLog_OperationResult::GetTypeName() const {
+  return "location.nearby.analytics.proto.ConnectionsLog.OperationResult";
+}
+
+
 // ===================================================================
 
 class ConnectionsLog_StrategySession::_Internal {
@@ -3328,23 +3593,23 @@ class ConnectionsLog_ConnectionAttempt::_Internal {
  public:
   using HasBits = decltype(std::declval<ConnectionsLog_ConnectionAttempt>()._has_bits_);
   static void set_has_duration_millis(HasBits* has_bits) {
-    (*has_bits)[0] |= 4u;
-  }
-  static void set_has_type(HasBits* has_bits) {
     (*has_bits)[0] |= 8u;
   }
-  static void set_has_direction(HasBits* has_bits) {
+  static void set_has_type(HasBits* has_bits) {
     (*has_bits)[0] |= 16u;
   }
-  static void set_has_medium(HasBits* has_bits) {
+  static void set_has_direction(HasBits* has_bits) {
     (*has_bits)[0] |= 32u;
   }
-  static void set_has_attempt_result(HasBits* has_bits) {
+  static void set_has_medium(HasBits* has_bits) {
     (*has_bits)[0] |= 64u;
   }
-  static void set_has_client_flow_id(HasBits* has_bits) {
+  static void set_has_attempt_result(HasBits* has_bits) {
     (*has_bits)[0] |= 128u;
   }
+  static void set_has_client_flow_id(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
   static void set_has_connection_token(HasBits* has_bits) {
     (*has_bits)[0] |= 1u;
   }
@@ -3352,12 +3617,20 @@ class ConnectionsLog_ConnectionAttempt::_Internal {
   static void set_has_connection_attempt_metadata(HasBits* has_bits) {
     (*has_bits)[0] |= 2u;
   }
+  static const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult& operation_result(const ConnectionsLog_ConnectionAttempt* msg);
+  static void set_has_operation_result(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
 };
 
 const ::location::nearby::analytics::proto::ConnectionsLog_ConnectionAttemptMetadata&
 ConnectionsLog_ConnectionAttempt::_Internal::connection_attempt_metadata(const ConnectionsLog_ConnectionAttempt* msg) {
   return *msg->connection_attempt_metadata_;
 }
+const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult&
+ConnectionsLog_ConnectionAttempt::_Internal::operation_result(const ConnectionsLog_ConnectionAttempt* msg) {
+  return *msg->operation_result_;
+}
 ConnectionsLog_ConnectionAttempt::ConnectionsLog_ConnectionAttempt(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                          bool is_message_owned)
   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
@@ -3384,6 +3657,11 @@ ConnectionsLog_ConnectionAttempt::ConnectionsLog_ConnectionAttempt(const Connect
   } else {
     connection_attempt_metadata_ = nullptr;
   }
+  if (from._internal_has_operation_result()) {
+    operation_result_ = new ::location::nearby::analytics::proto::ConnectionsLog_OperationResult(*from.operation_result_);
+  } else {
+    operation_result_ = nullptr;
+  }
   ::memcpy(&duration_millis_, &from.duration_millis_,
     static_cast<size_t>(reinterpret_cast<char*>(&client_flow_id_) -
     reinterpret_cast<char*>(&duration_millis_)) + sizeof(client_flow_id_));
@@ -3412,6 +3690,7 @@ inline void ConnectionsLog_ConnectionAttempt::SharedDtor() {
   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
   connection_token_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
   if (this != internal_default_instance()) delete connection_attempt_metadata_;
+  if (this != internal_default_instance()) delete operation_result_;
 }
 
 void ConnectionsLog_ConnectionAttempt::ArenaDtor(void* object) {
@@ -3431,7 +3710,7 @@ void ConnectionsLog_ConnectionAttempt::Clear() {
   (void) cached_has_bits;
 
   cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000003u) {
+  if (cached_has_bits & 0x00000007u) {
     if (cached_has_bits & 0x00000001u) {
       connection_token_.ClearNonDefaultToEmpty();
     }
@@ -3439,12 +3718,17 @@ void ConnectionsLog_ConnectionAttempt::Clear() {
       GOOGLE_DCHECK(connection_attempt_metadata_ != nullptr);
       connection_attempt_metadata_->Clear();
     }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(operation_result_ != nullptr);
+      operation_result_->Clear();
+    }
   }
-  if (cached_has_bits & 0x000000fcu) {
+  if (cached_has_bits & 0x000000f8u) {
     ::memset(&duration_millis_, 0, static_cast<size_t>(
-        reinterpret_cast<char*>(&client_flow_id_) -
-        reinterpret_cast<char*>(&duration_millis_)) + sizeof(client_flow_id_));
+        reinterpret_cast<char*>(&attempt_result_) -
+        reinterpret_cast<char*>(&duration_millis_)) + sizeof(attempt_result_));
   }
+  client_flow_id_ = int64_t{0};
   _has_bits_.Clear();
   _internal_metadata_.Clear<std::string>();
 }
@@ -3543,6 +3827,14 @@ const char* ConnectionsLog_ConnectionAttempt::_InternalParse(const char* ptr, ::
         } else
           goto handle_unusual;
         continue;
+      // optional .location.nearby.analytics.proto.ConnectionsLog.OperationResult operation_result = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+          ptr = ctx->ParseMessage(_internal_mutable_operation_result(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
       default:
         goto handle_unusual;
     }  // switch
@@ -3575,41 +3867,41 @@ uint8_t* ConnectionsLog_ConnectionAttempt::_InternalSerialize(
 
   cached_has_bits = _has_bits_[0];
   // optional int64 duration_millis = 1;
-  if (cached_has_bits & 0x00000004u) {
+  if (cached_has_bits & 0x00000008u) {
     target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_duration_millis(), target);
   }
 
   // optional .location.nearby.proto.connections.ConnectionAttemptType type = 2;
-  if (cached_has_bits & 0x00000008u) {
+  if (cached_has_bits & 0x00000010u) {
     target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
       2, this->_internal_type(), target);
   }
 
   // optional .location.nearby.proto.connections.ConnectionAttemptDirection direction = 3;
-  if (cached_has_bits & 0x00000010u) {
+  if (cached_has_bits & 0x00000020u) {
     target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
       3, this->_internal_direction(), target);
   }
 
   // optional .location.nearby.proto.connections.Medium medium = 4;
-  if (cached_has_bits & 0x00000020u) {
+  if (cached_has_bits & 0x00000040u) {
     target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
       4, this->_internal_medium(), target);
   }
 
   // optional .location.nearby.proto.connections.ConnectionAttemptResult attempt_result = 5;
-  if (cached_has_bits & 0x00000040u) {
+  if (cached_has_bits & 0x00000080u) {
     target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
       5, this->_internal_attempt_result(), target);
   }
 
   // optional int64 client_flow_id = 6;
-  if (cached_has_bits & 0x00000080u) {
+  if (cached_has_bits & 0x00000100u) {
     target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(6, this->_internal_client_flow_id(), target);
   }
@@ -3628,6 +3920,14 @@ uint8_t* ConnectionsLog_ConnectionAttempt::_InternalSerialize(
         8, _Internal::connection_attempt_metadata(this), target, stream);
   }
 
+  // optional .location.nearby.analytics.proto.ConnectionsLog.OperationResult operation_result = 9;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        9, _Internal::operation_result(this), target, stream);
+  }
+
   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
@@ -3660,41 +3960,48 @@ size_t ConnectionsLog_ConnectionAttempt::ByteSizeLong() const {
           *connection_attempt_metadata_);
     }
 
-    // optional int64 duration_millis = 1;
+    // optional .location.nearby.analytics.proto.ConnectionsLog.OperationResult operation_result = 9;
     if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *operation_result_);
+    }
+
+    // optional int64 duration_millis = 1;
+    if (cached_has_bits & 0x00000008u) {
       total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_duration_millis());
     }
 
     // optional .location.nearby.proto.connections.ConnectionAttemptType type = 2;
-    if (cached_has_bits & 0x00000008u) {
+    if (cached_has_bits & 0x00000010u) {
       total_size += 1 +
         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type());
     }
 
     // optional .location.nearby.proto.connections.ConnectionAttemptDirection direction = 3;
-    if (cached_has_bits & 0x00000010u) {
+    if (cached_has_bits & 0x00000020u) {
       total_size += 1 +
         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_direction());
     }
 
     // optional .location.nearby.proto.connections.Medium medium = 4;
-    if (cached_has_bits & 0x00000020u) {
+    if (cached_has_bits & 0x00000040u) {
       total_size += 1 +
         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_medium());
     }
 
     // optional .location.nearby.proto.connections.ConnectionAttemptResult attempt_result = 5;
-    if (cached_has_bits & 0x00000040u) {
+    if (cached_has_bits & 0x00000080u) {
       total_size += 1 +
         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_attempt_result());
     }
 
-    // optional int64 client_flow_id = 6;
-    if (cached_has_bits & 0x00000080u) {
-      total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_client_flow_id());
-    }
-
   }
+  // optional int64 client_flow_id = 6;
+  if (cached_has_bits & 0x00000100u) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_client_flow_id());
+  }
+
   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
   }
@@ -3724,25 +4031,28 @@ void ConnectionsLog_ConnectionAttempt::MergeFrom(const ConnectionsLog_Connection
       _internal_mutable_connection_attempt_metadata()->::location::nearby::analytics::proto::ConnectionsLog_ConnectionAttemptMetadata::MergeFrom(from._internal_connection_attempt_metadata());
     }
     if (cached_has_bits & 0x00000004u) {
-      duration_millis_ = from.duration_millis_;
+      _internal_mutable_operation_result()->::location::nearby::analytics::proto::ConnectionsLog_OperationResult::MergeFrom(from._internal_operation_result());
     }
     if (cached_has_bits & 0x00000008u) {
-      type_ = from.type_;
+      duration_millis_ = from.duration_millis_;
     }
     if (cached_has_bits & 0x00000010u) {
-      direction_ = from.direction_;
+      type_ = from.type_;
     }
     if (cached_has_bits & 0x00000020u) {
-      medium_ = from.medium_;
+      direction_ = from.direction_;
     }
     if (cached_has_bits & 0x00000040u) {
-      attempt_result_ = from.attempt_result_;
+      medium_ = from.medium_;
     }
     if (cached_has_bits & 0x00000080u) {
-      client_flow_id_ = from.client_flow_id_;
+      attempt_result_ = from.attempt_result_;
     }
     _has_bits_[0] |= cached_has_bits;
   }
+  if (cached_has_bits & 0x00000100u) {
+    _internal_set_client_flow_id(from._internal_client_flow_id());
+  }
   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
 }
 
@@ -3787,28 +4097,36 @@ class ConnectionsLog_EstablishedConnection::_Internal {
  public:
   using HasBits = decltype(std::declval<ConnectionsLog_EstablishedConnection>()._has_bits_);
   static void set_has_duration_millis(HasBits* has_bits) {
-    (*has_bits)[0] |= 2u;
-  }
-  static void set_has_medium(HasBits* has_bits) {
     (*has_bits)[0] |= 4u;
   }
-  static void set_has_disconnection_reason(HasBits* has_bits) {
+  static void set_has_medium(HasBits* has_bits) {
     (*has_bits)[0] |= 8u;
   }
-  static void set_has_client_flow_id(HasBits* has_bits) {
+  static void set_has_disconnection_reason(HasBits* has_bits) {
     (*has_bits)[0] |= 16u;
   }
+  static void set_has_client_flow_id(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
   static void set_has_connection_token(HasBits* has_bits) {
     (*has_bits)[0] |= 1u;
   }
   static void set_has_type(HasBits* has_bits) {
-    (*has_bits)[0] |= 32u;
+    (*has_bits)[0] |= 64u;
   }
   static void set_has_safe_disconnection_result(HasBits* has_bits) {
-    (*has_bits)[0] |= 64u;
+    (*has_bits)[0] |= 128u;
+  }
+  static const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult& operation_result(const ConnectionsLog_EstablishedConnection* msg);
+  static void set_has_operation_result(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
   }
 };
 
+const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult&
+ConnectionsLog_EstablishedConnection::_Internal::operation_result(const ConnectionsLog_EstablishedConnection* msg) {
+  return *msg->operation_result_;
+}
 ConnectionsLog_EstablishedConnection::ConnectionsLog_EstablishedConnection(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                          bool is_message_owned)
   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned),
@@ -3834,6 +4152,11 @@ ConnectionsLog_EstablishedConnection::ConnectionsLog_EstablishedConnection(const
     connection_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_connection_token(), 
       GetArenaForAllocation());
   }
+  if (from._internal_has_operation_result()) {
+    operation_result_ = new ::location::nearby::analytics::proto::ConnectionsLog_OperationResult(*from.operation_result_);
+  } else {
+    operation_result_ = nullptr;
+  }
   ::memcpy(&duration_millis_, &from.duration_millis_,
     static_cast<size_t>(reinterpret_cast<char*>(&safe_disconnection_result_) -
     reinterpret_cast<char*>(&duration_millis_)) + sizeof(safe_disconnection_result_));
@@ -3846,9 +4169,9 @@ connection_token_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyS
   connection_token_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 ::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
-    reinterpret_cast<char*>(&duration_millis_) - reinterpret_cast<char*>(this)),
+    reinterpret_cast<char*>(&operation_result_) - reinterpret_cast<char*>(this)),
     0, static_cast<size_t>(reinterpret_cast<char*>(&safe_disconnection_result_) -
-    reinterpret_cast<char*>(&duration_millis_)) + sizeof(safe_disconnection_result_));
+    reinterpret_cast<char*>(&operation_result_)) + sizeof(safe_disconnection_result_));
 }
 
 ConnectionsLog_EstablishedConnection::~ConnectionsLog_EstablishedConnection() {
@@ -3861,6 +4184,7 @@ ConnectionsLog_EstablishedConnection::~ConnectionsLog_EstablishedConnection() {
 inline void ConnectionsLog_EstablishedConnection::SharedDtor() {
   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
   connection_token_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (this != internal_default_instance()) delete operation_result_;
 }
 
 void ConnectionsLog_EstablishedConnection::ArenaDtor(void* object) {
@@ -3882,10 +4206,16 @@ void ConnectionsLog_EstablishedConnection::Clear() {
   sent_payload_.Clear();
   received_payload_.Clear();
   cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000001u) {
-    connection_token_.ClearNonDefaultToEmpty();
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      connection_token_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(operation_result_ != nullptr);
+      operation_result_->Clear();
+    }
   }
-  if (cached_has_bits & 0x0000007eu) {
+  if (cached_has_bits & 0x000000fcu) {
     ::memset(&duration_millis_, 0, static_cast<size_t>(
         reinterpret_cast<char*>(&safe_disconnection_result_) -
         reinterpret_cast<char*>(&duration_millis_)) + sizeof(safe_disconnection_result_));
@@ -4006,6 +4336,14 @@ const char* ConnectionsLog_EstablishedConnection::_InternalParse(const char* ptr
         } else
           goto handle_unusual;
         continue;
+      // optional .location.nearby.analytics.proto.ConnectionsLog.OperationResult operation_result = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          ptr = ctx->ParseMessage(_internal_mutable_operation_result(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
       default:
         goto handle_unusual;
     }  // switch
@@ -4038,13 +4376,13 @@ uint8_t* ConnectionsLog_EstablishedConnection::_InternalSerialize(
 
   cached_has_bits = _has_bits_[0];
   // optional int64 duration_millis = 1;
-  if (cached_has_bits & 0x00000002u) {
+  if (cached_has_bits & 0x00000004u) {
     target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_duration_millis(), target);
   }
 
   // optional .location.nearby.proto.connections.Medium medium = 2;
-  if (cached_has_bits & 0x00000004u) {
+  if (cached_has_bits & 0x00000008u) {
     target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
       2, this->_internal_medium(), target);
@@ -4067,14 +4405,14 @@ uint8_t* ConnectionsLog_EstablishedConnection::_InternalSerialize(
   }
 
   // optional .location.nearby.proto.connections.DisconnectionReason disconnection_reason = 5;
-  if (cached_has_bits & 0x00000008u) {
+  if (cached_has_bits & 0x00000010u) {
     target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
       5, this->_internal_disconnection_reason(), target);
   }
 
   // optional int64 client_flow_id = 6;
-  if (cached_has_bits & 0x00000010u) {
+  if (cached_has_bits & 0x00000020u) {
     target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(6, this->_internal_client_flow_id(), target);
   }
@@ -4086,19 +4424,27 @@ uint8_t* ConnectionsLog_EstablishedConnection::_InternalSerialize(
   }
 
   // optional .location.nearby.proto.connections.ConnectionAttemptType type = 8;
-  if (cached_has_bits & 0x00000020u) {
+  if (cached_has_bits & 0x00000040u) {
     target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
       8, this->_internal_type(), target);
   }
 
   // optional .location.nearby.analytics.proto.ConnectionsLog.EstablishedConnection.SafeDisconnectionResult safe_disconnection_result = 9;
-  if (cached_has_bits & 0x00000040u) {
+  if (cached_has_bits & 0x00000080u) {
     target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
       9, this->_internal_safe_disconnection_result(), target);
   }
 
+  // optional .location.nearby.analytics.proto.ConnectionsLog.OperationResult operation_result = 10;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        10, _Internal::operation_result(this), target, stream);
+  }
+
   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
@@ -4130,7 +4476,7 @@ size_t ConnectionsLog_EstablishedConnection::ByteSizeLong() const {
   }
 
   cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x0000007fu) {
+  if (cached_has_bits & 0x000000ffu) {
     // optional string connection_token = 7;
     if (cached_has_bits & 0x00000001u) {
       total_size += 1 +
@@ -4138,36 +4484,43 @@ size_t ConnectionsLog_EstablishedConnection::ByteSizeLong() const {
           this->_internal_connection_token());
     }
 
-    // optional int64 duration_millis = 1;
+    // optional .location.nearby.analytics.proto.ConnectionsLog.OperationResult operation_result = 10;
     if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *operation_result_);
+    }
+
+    // optional int64 duration_millis = 1;
+    if (cached_has_bits & 0x00000004u) {
       total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_duration_millis());
     }
 
     // optional .location.nearby.proto.connections.Medium medium = 2;
-    if (cached_has_bits & 0x00000004u) {
+    if (cached_has_bits & 0x00000008u) {
       total_size += 1 +
         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_medium());
     }
 
     // optional .location.nearby.proto.connections.DisconnectionReason disconnection_reason = 5;
-    if (cached_has_bits & 0x00000008u) {
+    if (cached_has_bits & 0x00000010u) {
       total_size += 1 +
         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_disconnection_reason());
     }
 
     // optional int64 client_flow_id = 6;
-    if (cached_has_bits & 0x00000010u) {
+    if (cached_has_bits & 0x00000020u) {
       total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_client_flow_id());
     }
 
     // optional .location.nearby.proto.connections.ConnectionAttemptType type = 8;
-    if (cached_has_bits & 0x00000020u) {
+    if (cached_has_bits & 0x00000040u) {
       total_size += 1 +
         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type());
     }
 
     // optional .location.nearby.analytics.proto.ConnectionsLog.EstablishedConnection.SafeDisconnectionResult safe_disconnection_result = 9;
-    if (cached_has_bits & 0x00000040u) {
+    if (cached_has_bits & 0x00000080u) {
       total_size += 1 +
         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_safe_disconnection_result());
     }
@@ -4196,26 +4549,29 @@ void ConnectionsLog_EstablishedConnection::MergeFrom(const ConnectionsLog_Establ
   sent_payload_.MergeFrom(from.sent_payload_);
   received_payload_.MergeFrom(from.received_payload_);
   cached_has_bits = from._has_bits_[0];
-  if (cached_has_bits & 0x0000007fu) {
+  if (cached_has_bits & 0x000000ffu) {
     if (cached_has_bits & 0x00000001u) {
       _internal_set_connection_token(from._internal_connection_token());
     }
     if (cached_has_bits & 0x00000002u) {
-      duration_millis_ = from.duration_millis_;
+      _internal_mutable_operation_result()->::location::nearby::analytics::proto::ConnectionsLog_OperationResult::MergeFrom(from._internal_operation_result());
     }
     if (cached_has_bits & 0x00000004u) {
-      medium_ = from.medium_;
+      duration_millis_ = from.duration_millis_;
     }
     if (cached_has_bits & 0x00000008u) {
-      disconnection_reason_ = from.disconnection_reason_;
+      medium_ = from.medium_;
     }
     if (cached_has_bits & 0x00000010u) {
-      client_flow_id_ = from.client_flow_id_;
+      disconnection_reason_ = from.disconnection_reason_;
     }
     if (cached_has_bits & 0x00000020u) {
-      type_ = from.type_;
+      client_flow_id_ = from.client_flow_id_;
     }
     if (cached_has_bits & 0x00000040u) {
+      type_ = from.type_;
+    }
+    if (cached_has_bits & 0x00000080u) {
       safe_disconnection_result_ = from.safe_disconnection_result_;
     }
     _has_bits_[0] |= cached_has_bits;
@@ -4250,9 +4606,9 @@ void ConnectionsLog_EstablishedConnection::InternalSwap(ConnectionsLog_Establish
   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
       PROTOBUF_FIELD_OFFSET(ConnectionsLog_EstablishedConnection, safe_disconnection_result_)
       + sizeof(ConnectionsLog_EstablishedConnection::safe_disconnection_result_)
-      - PROTOBUF_FIELD_OFFSET(ConnectionsLog_EstablishedConnection, duration_millis_)>(
-          reinterpret_cast<char*>(&duration_millis_),
-          reinterpret_cast<char*>(&other->duration_millis_));
+      - PROTOBUF_FIELD_OFFSET(ConnectionsLog_EstablishedConnection, operation_result_)>(
+          reinterpret_cast<char*>(&operation_result_),
+          reinterpret_cast<char*>(&other->operation_result_));
 }
 
 std::string ConnectionsLog_EstablishedConnection::GetTypeName() const {
@@ -4266,28 +4622,36 @@ class ConnectionsLog_Payload::_Internal {
  public:
   using HasBits = decltype(std::declval<ConnectionsLog_Payload>()._has_bits_);
   static void set_has_duration_millis(HasBits* has_bits) {
-    (*has_bits)[0] |= 1u;
-  }
-  static void set_has_type(HasBits* has_bits) {
-    (*has_bits)[0] |= 4u;
-  }
-  static void set_has_total_size_bytes(HasBits* has_bits) {
     (*has_bits)[0] |= 2u;
   }
-  static void set_has_num_bytes_transferred(HasBits* has_bits) {
-    (*has_bits)[0] |= 16u;
-  }
-  static void set_has_num_chunks(HasBits* has_bits) {
+  static void set_has_type(HasBits* has_bits) {
     (*has_bits)[0] |= 8u;
   }
-  static void set_has_status(HasBits* has_bits) {
+  static void set_has_total_size_bytes(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_num_bytes_transferred(HasBits* has_bits) {
     (*has_bits)[0] |= 32u;
   }
-  static void set_has_num_successful_auto_resume(HasBits* has_bits) {
+  static void set_has_num_chunks(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_status(HasBits* has_bits) {
     (*has_bits)[0] |= 64u;
   }
+  static void set_has_num_successful_auto_resume(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+  static const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult& operation_result(const ConnectionsLog_Payload* msg);
+  static void set_has_operation_result(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
 };
 
+const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult&
+ConnectionsLog_Payload::_Internal::operation_result(const ConnectionsLog_Payload* msg) {
+  return *msg->operation_result_;
+}
 ConnectionsLog_Payload::ConnectionsLog_Payload(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                          bool is_message_owned)
   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
@@ -4301,6 +4665,11 @@ ConnectionsLog_Payload::ConnectionsLog_Payload(const ConnectionsLog_Payload& fro
   : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
       _has_bits_(from._has_bits_) {
   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  if (from._internal_has_operation_result()) {
+    operation_result_ = new ::location::nearby::analytics::proto::ConnectionsLog_OperationResult(*from.operation_result_);
+  } else {
+    operation_result_ = nullptr;
+  }
   ::memcpy(&duration_millis_, &from.duration_millis_,
     static_cast<size_t>(reinterpret_cast<char*>(&num_successful_auto_resume_) -
     reinterpret_cast<char*>(&duration_millis_)) + sizeof(num_successful_auto_resume_));
@@ -4309,9 +4678,9 @@ ConnectionsLog_Payload::ConnectionsLog_Payload(const ConnectionsLog_Payload& fro
 
 inline void ConnectionsLog_Payload::SharedCtor() {
 ::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
-    reinterpret_cast<char*>(&duration_millis_) - reinterpret_cast<char*>(this)),
+    reinterpret_cast<char*>(&operation_result_) - reinterpret_cast<char*>(this)),
     0, static_cast<size_t>(reinterpret_cast<char*>(&num_successful_auto_resume_) -
-    reinterpret_cast<char*>(&duration_millis_)) + sizeof(num_successful_auto_resume_));
+    reinterpret_cast<char*>(&operation_result_)) + sizeof(num_successful_auto_resume_));
 }
 
 ConnectionsLog_Payload::~ConnectionsLog_Payload() {
@@ -4323,6 +4692,7 @@ ConnectionsLog_Payload::~ConnectionsLog_Payload() {
 
 inline void ConnectionsLog_Payload::SharedDtor() {
   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete operation_result_;
 }
 
 void ConnectionsLog_Payload::ArenaDtor(void* object) {
@@ -4342,7 +4712,11 @@ void ConnectionsLog_Payload::Clear() {
   (void) cached_has_bits;
 
   cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x0000007fu) {
+  if (cached_has_bits & 0x00000001u) {
+    GOOGLE_DCHECK(operation_result_ != nullptr);
+    operation_result_->Clear();
+  }
+  if (cached_has_bits & 0x000000feu) {
     ::memset(&duration_millis_, 0, static_cast<size_t>(
         reinterpret_cast<char*>(&num_successful_auto_resume_) -
         reinterpret_cast<char*>(&duration_millis_)) + sizeof(num_successful_auto_resume_));
@@ -4429,6 +4803,14 @@ const char* ConnectionsLog_Payload::_InternalParse(const char* ptr, ::PROTOBUF_N
         } else
           goto handle_unusual;
         continue;
+      // optional .location.nearby.analytics.proto.ConnectionsLog.OperationResult operation_result = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          ptr = ctx->ParseMessage(_internal_mutable_operation_result(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
       default:
         goto handle_unusual;
     }  // switch
@@ -4461,49 +4843,57 @@ uint8_t* ConnectionsLog_Payload::_InternalSerialize(
 
   cached_has_bits = _has_bits_[0];
   // optional int64 duration_millis = 1;
-  if (cached_has_bits & 0x00000001u) {
+  if (cached_has_bits & 0x00000002u) {
     target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_duration_millis(), target);
   }
 
   // optional .location.nearby.proto.connections.PayloadType type = 2;
-  if (cached_has_bits & 0x00000004u) {
+  if (cached_has_bits & 0x00000008u) {
     target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
       2, this->_internal_type(), target);
   }
 
   // optional int64 total_size_bytes = 3;
-  if (cached_has_bits & 0x00000002u) {
+  if (cached_has_bits & 0x00000004u) {
     target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->_internal_total_size_bytes(), target);
   }
 
   // optional int64 num_bytes_transferred = 4;
-  if (cached_has_bits & 0x00000010u) {
+  if (cached_has_bits & 0x00000020u) {
     target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(4, this->_internal_num_bytes_transferred(), target);
   }
 
   // optional int32 num_chunks = 5;
-  if (cached_has_bits & 0x00000008u) {
+  if (cached_has_bits & 0x00000010u) {
     target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->_internal_num_chunks(), target);
   }
 
   // optional .location.nearby.proto.connections.PayloadStatus status = 6;
-  if (cached_has_bits & 0x00000020u) {
+  if (cached_has_bits & 0x00000040u) {
     target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
       6, this->_internal_status(), target);
   }
 
   // optional int32 num_successful_auto_resume = 7;
-  if (cached_has_bits & 0x00000040u) {
+  if (cached_has_bits & 0x00000080u) {
     target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(7, this->_internal_num_successful_auto_resume(), target);
   }
 
+  // optional .location.nearby.analytics.proto.ConnectionsLog.OperationResult operation_result = 8;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        8, _Internal::operation_result(this), target, stream);
+  }
+
   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
@@ -4521,41 +4911,48 @@ size_t ConnectionsLog_Payload::ByteSizeLong() const {
   (void) cached_has_bits;
 
   cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x0000007fu) {
-    // optional int64 duration_millis = 1;
+  if (cached_has_bits & 0x000000ffu) {
+    // optional .location.nearby.analytics.proto.ConnectionsLog.OperationResult operation_result = 8;
     if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *operation_result_);
+    }
+
+    // optional int64 duration_millis = 1;
+    if (cached_has_bits & 0x00000002u) {
       total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_duration_millis());
     }
 
     // optional int64 total_size_bytes = 3;
-    if (cached_has_bits & 0x00000002u) {
+    if (cached_has_bits & 0x00000004u) {
       total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_total_size_bytes());
     }
 
     // optional .location.nearby.proto.connections.PayloadType type = 2;
-    if (cached_has_bits & 0x00000004u) {
+    if (cached_has_bits & 0x00000008u) {
       total_size += 1 +
         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type());
     }
 
     // optional int32 num_chunks = 5;
-    if (cached_has_bits & 0x00000008u) {
+    if (cached_has_bits & 0x00000010u) {
       total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_num_chunks());
     }
 
     // optional int64 num_bytes_transferred = 4;
-    if (cached_has_bits & 0x00000010u) {
+    if (cached_has_bits & 0x00000020u) {
       total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_num_bytes_transferred());
     }
 
     // optional .location.nearby.proto.connections.PayloadStatus status = 6;
-    if (cached_has_bits & 0x00000020u) {
+    if (cached_has_bits & 0x00000040u) {
       total_size += 1 +
         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_status());
     }
 
     // optional int32 num_successful_auto_resume = 7;
-    if (cached_has_bits & 0x00000040u) {
+    if (cached_has_bits & 0x00000080u) {
       total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_num_successful_auto_resume());
     }
 
@@ -4581,26 +4978,29 @@ void ConnectionsLog_Payload::MergeFrom(const ConnectionsLog_Payload& from) {
   (void) cached_has_bits;
 
   cached_has_bits = from._has_bits_[0];
-  if (cached_has_bits & 0x0000007fu) {
+  if (cached_has_bits & 0x000000ffu) {
     if (cached_has_bits & 0x00000001u) {
-      duration_millis_ = from.duration_millis_;
+      _internal_mutable_operation_result()->::location::nearby::analytics::proto::ConnectionsLog_OperationResult::MergeFrom(from._internal_operation_result());
     }
     if (cached_has_bits & 0x00000002u) {
-      total_size_bytes_ = from.total_size_bytes_;
+      duration_millis_ = from.duration_millis_;
     }
     if (cached_has_bits & 0x00000004u) {
-      type_ = from.type_;
+      total_size_bytes_ = from.total_size_bytes_;
     }
     if (cached_has_bits & 0x00000008u) {
-      num_chunks_ = from.num_chunks_;
+      type_ = from.type_;
     }
     if (cached_has_bits & 0x00000010u) {
-      num_bytes_transferred_ = from.num_bytes_transferred_;
+      num_chunks_ = from.num_chunks_;
     }
     if (cached_has_bits & 0x00000020u) {
-      status_ = from.status_;
+      num_bytes_transferred_ = from.num_bytes_transferred_;
     }
     if (cached_has_bits & 0x00000040u) {
+      status_ = from.status_;
+    }
+    if (cached_has_bits & 0x00000080u) {
       num_successful_auto_resume_ = from.num_successful_auto_resume_;
     }
     _has_bits_[0] |= cached_has_bits;
@@ -4626,9 +5026,9 @@ void ConnectionsLog_Payload::InternalSwap(ConnectionsLog_Payload* other) {
   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
       PROTOBUF_FIELD_OFFSET(ConnectionsLog_Payload, num_successful_auto_resume_)
       + sizeof(ConnectionsLog_Payload::num_successful_auto_resume_)
-      - PROTOBUF_FIELD_OFFSET(ConnectionsLog_Payload, duration_millis_)>(
-          reinterpret_cast<char*>(&duration_millis_),
-          reinterpret_cast<char*>(&other->duration_millis_));
+      - PROTOBUF_FIELD_OFFSET(ConnectionsLog_Payload, operation_result_)>(
+          reinterpret_cast<char*>(&operation_result_),
+          reinterpret_cast<char*>(&other->operation_result_));
 }
 
 std::string ConnectionsLog_Payload::GetTypeName() const {
@@ -4642,31 +5042,39 @@ class ConnectionsLog_BandwidthUpgradeAttempt::_Internal {
  public:
   using HasBits = decltype(std::declval<ConnectionsLog_BandwidthUpgradeAttempt>()._has_bits_);
   static void set_has_direction(HasBits* has_bits) {
-    (*has_bits)[0] |= 4u;
-  }
-  static void set_has_duration_millis(HasBits* has_bits) {
-    (*has_bits)[0] |= 2u;
-  }
-  static void set_has_from_medium(HasBits* has_bits) {
     (*has_bits)[0] |= 8u;
   }
-  static void set_has_to_medium(HasBits* has_bits) {
+  static void set_has_duration_millis(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_from_medium(HasBits* has_bits) {
     (*has_bits)[0] |= 16u;
   }
-  static void set_has_upgrade_result(HasBits* has_bits) {
+  static void set_has_to_medium(HasBits* has_bits) {
     (*has_bits)[0] |= 32u;
   }
+  static void set_has_upgrade_result(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
   static void set_has_error_stage(HasBits* has_bits) {
-    (*has_bits)[0] |= 128u;
+    (*has_bits)[0] |= 256u;
   }
   static void set_has_client_flow_id(HasBits* has_bits) {
-    (*has_bits)[0] |= 64u;
+    (*has_bits)[0] |= 128u;
   }
   static void set_has_connection_token(HasBits* has_bits) {
     (*has_bits)[0] |= 1u;
   }
+  static const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult& operation_result(const ConnectionsLog_BandwidthUpgradeAttempt* msg);
+  static void set_has_operation_result(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
 };
 
+const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult&
+ConnectionsLog_BandwidthUpgradeAttempt::_Internal::operation_result(const ConnectionsLog_BandwidthUpgradeAttempt* msg) {
+  return *msg->operation_result_;
+}
 ConnectionsLog_BandwidthUpgradeAttempt::ConnectionsLog_BandwidthUpgradeAttempt(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                          bool is_message_owned)
   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
@@ -4688,6 +5096,11 @@ ConnectionsLog_BandwidthUpgradeAttempt::ConnectionsLog_BandwidthUpgradeAttempt(c
     connection_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_connection_token(), 
       GetArenaForAllocation());
   }
+  if (from._internal_has_operation_result()) {
+    operation_result_ = new ::location::nearby::analytics::proto::ConnectionsLog_OperationResult(*from.operation_result_);
+  } else {
+    operation_result_ = nullptr;
+  }
   ::memcpy(&duration_millis_, &from.duration_millis_,
     static_cast<size_t>(reinterpret_cast<char*>(&error_stage_) -
     reinterpret_cast<char*>(&duration_millis_)) + sizeof(error_stage_));
@@ -4700,9 +5113,9 @@ connection_token_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyS
   connection_token_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 ::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
-    reinterpret_cast<char*>(&duration_millis_) - reinterpret_cast<char*>(this)),
+    reinterpret_cast<char*>(&operation_result_) - reinterpret_cast<char*>(this)),
     0, static_cast<size_t>(reinterpret_cast<char*>(&error_stage_) -
-    reinterpret_cast<char*>(&duration_millis_)) + sizeof(error_stage_));
+    reinterpret_cast<char*>(&operation_result_)) + sizeof(error_stage_));
 }
 
 ConnectionsLog_BandwidthUpgradeAttempt::~ConnectionsLog_BandwidthUpgradeAttempt() {
@@ -4715,6 +5128,7 @@ ConnectionsLog_BandwidthUpgradeAttempt::~ConnectionsLog_BandwidthUpgradeAttempt(
 inline void ConnectionsLog_BandwidthUpgradeAttempt::SharedDtor() {
   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
   connection_token_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (this != internal_default_instance()) delete operation_result_;
 }
 
 void ConnectionsLog_BandwidthUpgradeAttempt::ArenaDtor(void* object) {
@@ -4734,14 +5148,21 @@ void ConnectionsLog_BandwidthUpgradeAttempt::Clear() {
   (void) cached_has_bits;
 
   cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000001u) {
-    connection_token_.ClearNonDefaultToEmpty();
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      connection_token_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(operation_result_ != nullptr);
+      operation_result_->Clear();
+    }
   }
-  if (cached_has_bits & 0x000000feu) {
+  if (cached_has_bits & 0x000000fcu) {
     ::memset(&duration_millis_, 0, static_cast<size_t>(
-        reinterpret_cast<char*>(&error_stage_) -
-        reinterpret_cast<char*>(&duration_millis_)) + sizeof(error_stage_));
+        reinterpret_cast<char*>(&client_flow_id_) -
+        reinterpret_cast<char*>(&duration_millis_)) + sizeof(client_flow_id_));
   }
+  error_stage_ = 0;
   _has_bits_.Clear();
   _internal_metadata_.Clear<std::string>();
 }
@@ -4845,6 +5266,14 @@ const char* ConnectionsLog_BandwidthUpgradeAttempt::_InternalParse(const char* p
         } else
           goto handle_unusual;
         continue;
+      // optional .location.nearby.analytics.proto.ConnectionsLog.OperationResult operation_result = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+          ptr = ctx->ParseMessage(_internal_mutable_operation_result(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
       default:
         goto handle_unusual;
     }  // switch
@@ -4877,48 +5306,48 @@ uint8_t* ConnectionsLog_BandwidthUpgradeAttempt::_InternalSerialize(
 
   cached_has_bits = _has_bits_[0];
   // optional .location.nearby.proto.connections.ConnectionAttemptDirection direction = 1;
-  if (cached_has_bits & 0x00000004u) {
+  if (cached_has_bits & 0x00000008u) {
     target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
       1, this->_internal_direction(), target);
   }
 
   // optional int64 duration_millis = 2;
-  if (cached_has_bits & 0x00000002u) {
+  if (cached_has_bits & 0x00000004u) {
     target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->_internal_duration_millis(), target);
   }
 
   // optional .location.nearby.proto.connections.Medium from_medium = 3;
-  if (cached_has_bits & 0x00000008u) {
+  if (cached_has_bits & 0x00000010u) {
     target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
       3, this->_internal_from_medium(), target);
   }
 
   // optional .location.nearby.proto.connections.Medium to_medium = 4;
-  if (cached_has_bits & 0x00000010u) {
+  if (cached_has_bits & 0x00000020u) {
     target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
       4, this->_internal_to_medium(), target);
   }
 
   // optional .location.nearby.proto.connections.BandwidthUpgradeResult upgrade_result = 5;
-  if (cached_has_bits & 0x00000020u) {
+  if (cached_has_bits & 0x00000040u) {
     target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
       5, this->_internal_upgrade_result(), target);
   }
 
   // optional .location.nearby.proto.connections.BandwidthUpgradeErrorStage error_stage = 6;
-  if (cached_has_bits & 0x00000080u) {
+  if (cached_has_bits & 0x00000100u) {
     target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
       6, this->_internal_error_stage(), target);
   }
 
   // optional int64 client_flow_id = 7;
-  if (cached_has_bits & 0x00000040u) {
+  if (cached_has_bits & 0x00000080u) {
     target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(7, this->_internal_client_flow_id(), target);
   }
@@ -4929,6 +5358,14 @@ uint8_t* ConnectionsLog_BandwidthUpgradeAttempt::_InternalSerialize(
         8, this->_internal_connection_token(), target);
   }
 
+  // optional .location.nearby.analytics.proto.ConnectionsLog.OperationResult operation_result = 9;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        9, _Internal::operation_result(this), target, stream);
+  }
+
   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
@@ -4954,47 +5391,54 @@ size_t ConnectionsLog_BandwidthUpgradeAttempt::ByteSizeLong() const {
           this->_internal_connection_token());
     }
 
-    // optional int64 duration_millis = 2;
+    // optional .location.nearby.analytics.proto.ConnectionsLog.OperationResult operation_result = 9;
     if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *operation_result_);
+    }
+
+    // optional int64 duration_millis = 2;
+    if (cached_has_bits & 0x00000004u) {
       total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_duration_millis());
     }
 
     // optional .location.nearby.proto.connections.ConnectionAttemptDirection direction = 1;
-    if (cached_has_bits & 0x00000004u) {
+    if (cached_has_bits & 0x00000008u) {
       total_size += 1 +
         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_direction());
     }
 
     // optional .location.nearby.proto.connections.Medium from_medium = 3;
-    if (cached_has_bits & 0x00000008u) {
+    if (cached_has_bits & 0x00000010u) {
       total_size += 1 +
         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_from_medium());
     }
 
     // optional .location.nearby.proto.connections.Medium to_medium = 4;
-    if (cached_has_bits & 0x00000010u) {
+    if (cached_has_bits & 0x00000020u) {
       total_size += 1 +
         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_to_medium());
     }
 
     // optional .location.nearby.proto.connections.BandwidthUpgradeResult upgrade_result = 5;
-    if (cached_has_bits & 0x00000020u) {
+    if (cached_has_bits & 0x00000040u) {
       total_size += 1 +
         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_upgrade_result());
     }
 
     // optional int64 client_flow_id = 7;
-    if (cached_has_bits & 0x00000040u) {
+    if (cached_has_bits & 0x00000080u) {
       total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_client_flow_id());
     }
 
-    // optional .location.nearby.proto.connections.BandwidthUpgradeErrorStage error_stage = 6;
-    if (cached_has_bits & 0x00000080u) {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_error_stage());
-    }
-
   }
+  // optional .location.nearby.proto.connections.BandwidthUpgradeErrorStage error_stage = 6;
+  if (cached_has_bits & 0x00000100u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_error_stage());
+  }
+
   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
   }
@@ -5021,28 +5465,31 @@ void ConnectionsLog_BandwidthUpgradeAttempt::MergeFrom(const ConnectionsLog_Band
       _internal_set_connection_token(from._internal_connection_token());
     }
     if (cached_has_bits & 0x00000002u) {
-      duration_millis_ = from.duration_millis_;
+      _internal_mutable_operation_result()->::location::nearby::analytics::proto::ConnectionsLog_OperationResult::MergeFrom(from._internal_operation_result());
     }
     if (cached_has_bits & 0x00000004u) {
-      direction_ = from.direction_;
+      duration_millis_ = from.duration_millis_;
     }
     if (cached_has_bits & 0x00000008u) {
-      from_medium_ = from.from_medium_;
+      direction_ = from.direction_;
     }
     if (cached_has_bits & 0x00000010u) {
-      to_medium_ = from.to_medium_;
+      from_medium_ = from.from_medium_;
     }
     if (cached_has_bits & 0x00000020u) {
-      upgrade_result_ = from.upgrade_result_;
+      to_medium_ = from.to_medium_;
     }
     if (cached_has_bits & 0x00000040u) {
-      client_flow_id_ = from.client_flow_id_;
+      upgrade_result_ = from.upgrade_result_;
     }
     if (cached_has_bits & 0x00000080u) {
-      error_stage_ = from.error_stage_;
+      client_flow_id_ = from.client_flow_id_;
     }
     _has_bits_[0] |= cached_has_bits;
   }
+  if (cached_has_bits & 0x00000100u) {
+    _internal_set_error_stage(from._internal_error_stage());
+  }
   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
 }
 
@@ -5071,9 +5518,9 @@ void ConnectionsLog_BandwidthUpgradeAttempt::InternalSwap(ConnectionsLog_Bandwid
   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
       PROTOBUF_FIELD_OFFSET(ConnectionsLog_BandwidthUpgradeAttempt, error_stage_)
       + sizeof(ConnectionsLog_BandwidthUpgradeAttempt::error_stage_)
-      - PROTOBUF_FIELD_OFFSET(ConnectionsLog_BandwidthUpgradeAttempt, duration_millis_)>(
-          reinterpret_cast<char*>(&duration_millis_),
-          reinterpret_cast<char*>(&other->duration_millis_));
+      - PROTOBUF_FIELD_OFFSET(ConnectionsLog_BandwidthUpgradeAttempt, operation_result_)>(
+          reinterpret_cast<char*>(&operation_result_),
+          reinterpret_cast<char*>(&other->operation_result_));
 }
 
 std::string ConnectionsLog_BandwidthUpgradeAttempt::GetTypeName() const {
@@ -7808,6 +8255,9 @@ PROTOBUF_NAMESPACE_OPEN
 template<> PROTOBUF_NOINLINE ::location::nearby::analytics::proto::ConnectionsLog_ClientSession* Arena::CreateMaybeMessage< ::location::nearby::analytics::proto::ConnectionsLog_ClientSession >(Arena* arena) {
   return Arena::CreateMessageInternal< ::location::nearby::analytics::proto::ConnectionsLog_ClientSession >(arena);
 }
+template<> PROTOBUF_NOINLINE ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* Arena::CreateMaybeMessage< ::location::nearby::analytics::proto::ConnectionsLog_OperationResult >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::location::nearby::analytics::proto::ConnectionsLog_OperationResult >(arena);
+}
 template<> PROTOBUF_NOINLINE ::location::nearby::analytics::proto::ConnectionsLog_StrategySession* Arena::CreateMaybeMessage< ::location::nearby::analytics::proto::ConnectionsLog_StrategySession >(Arena* arena) {
   return Arena::CreateMessageInternal< ::location::nearby::analytics::proto::ConnectionsLog_StrategySession >(arena);
 }
diff --git a/compiled_proto/internal/proto/analytics/connections_log.pb.h b/compiled_proto/internal/proto/analytics/connections_log.pb.h
index 071f3dc3..97d41143 100644
--- a/compiled_proto/internal/proto/analytics/connections_log.pb.h
+++ b/compiled_proto/internal/proto/analytics/connections_log.pb.h
@@ -47,7 +47,7 @@ struct TableStruct_internal_2fproto_2fanalytics_2fconnections_5flog_2eproto {
     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[17]
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[18]
     PROTOBUF_SECTION_VARIABLE(protodesc_cold);
   static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
   static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
@@ -96,6 +96,9 @@ extern ConnectionsLog_ErrorCodeDefaultTypeInternal _ConnectionsLog_ErrorCode_def
 class ConnectionsLog_EstablishedConnection;
 struct ConnectionsLog_EstablishedConnectionDefaultTypeInternal;
 extern ConnectionsLog_EstablishedConnectionDefaultTypeInternal _ConnectionsLog_EstablishedConnection_default_instance_;
+class ConnectionsLog_OperationResult;
+struct ConnectionsLog_OperationResultDefaultTypeInternal;
+extern ConnectionsLog_OperationResultDefaultTypeInternal _ConnectionsLog_OperationResult_default_instance_;
 class ConnectionsLog_Payload;
 struct ConnectionsLog_PayloadDefaultTypeInternal;
 extern ConnectionsLog_PayloadDefaultTypeInternal _ConnectionsLog_Payload_default_instance_;
@@ -126,6 +129,7 @@ template<> ::location::nearby::analytics::proto::ConnectionsLog_DiscoveryMetadat
 template<> ::location::nearby::analytics::proto::ConnectionsLog_DiscoveryPhase* Arena::CreateMaybeMessage<::location::nearby::analytics::proto::ConnectionsLog_DiscoveryPhase>(Arena*);
 template<> ::location::nearby::analytics::proto::ConnectionsLog_ErrorCode* Arena::CreateMaybeMessage<::location::nearby::analytics::proto::ConnectionsLog_ErrorCode>(Arena*);
 template<> ::location::nearby::analytics::proto::ConnectionsLog_EstablishedConnection* Arena::CreateMaybeMessage<::location::nearby::analytics::proto::ConnectionsLog_EstablishedConnection>(Arena*);
+template<> ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* Arena::CreateMaybeMessage<::location::nearby::analytics::proto::ConnectionsLog_OperationResult>(Arena*);
 template<> ::location::nearby::analytics::proto::ConnectionsLog_Payload* Arena::CreateMaybeMessage<::location::nearby::analytics::proto::ConnectionsLog_Payload>(Arena*);
 template<> ::location::nearby::analytics::proto::ConnectionsLog_RawUwbRangingEvent* Arena::CreateMaybeMessage<::location::nearby::analytics::proto::ConnectionsLog_RawUwbRangingEvent>(Arena*);
 template<> ::location::nearby::analytics::proto::ConnectionsLog_StrategySession* Arena::CreateMaybeMessage<::location::nearby::analytics::proto::ConnectionsLog_StrategySession>(Arena*);
@@ -355,6 +359,163 @@ class ConnectionsLog_ClientSession final :
 };
 // -------------------------------------------------------------------
 
+class ConnectionsLog_OperationResult final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.analytics.proto.ConnectionsLog.OperationResult) */ {
+ public:
+  inline ConnectionsLog_OperationResult() : ConnectionsLog_OperationResult(nullptr) {}
+  ~ConnectionsLog_OperationResult() override;
+  explicit constexpr ConnectionsLog_OperationResult(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ConnectionsLog_OperationResult(const ConnectionsLog_OperationResult& from);
+  ConnectionsLog_OperationResult(ConnectionsLog_OperationResult&& from) noexcept
+    : ConnectionsLog_OperationResult() {
+    *this = ::std::move(from);
+  }
+
+  inline ConnectionsLog_OperationResult& operator=(const ConnectionsLog_OperationResult& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ConnectionsLog_OperationResult& operator=(ConnectionsLog_OperationResult&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ConnectionsLog_OperationResult& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ConnectionsLog_OperationResult* internal_default_instance() {
+    return reinterpret_cast<const ConnectionsLog_OperationResult*>(
+               &_ConnectionsLog_OperationResult_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(ConnectionsLog_OperationResult& a, ConnectionsLog_OperationResult& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ConnectionsLog_OperationResult* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ConnectionsLog_OperationResult* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ConnectionsLog_OperationResult* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ConnectionsLog_OperationResult>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ConnectionsLog_OperationResult& from);
+  void MergeFrom(const ConnectionsLog_OperationResult& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ConnectionsLog_OperationResult* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "location.nearby.analytics.proto.ConnectionsLog.OperationResult";
+  }
+  protected:
+  explicit ConnectionsLog_OperationResult(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kResultCategoryFieldNumber = 1,
+    kResultCodeFieldNumber = 2,
+  };
+  // optional .location.nearby.proto.connections.OperationResultCategory result_category = 1;
+  bool has_result_category() const;
+  private:
+  bool _internal_has_result_category() const;
+  public:
+  void clear_result_category();
+  ::location::nearby::proto::connections::OperationResultCategory result_category() const;
+  void set_result_category(::location::nearby::proto::connections::OperationResultCategory value);
+  private:
+  ::location::nearby::proto::connections::OperationResultCategory _internal_result_category() const;
+  void _internal_set_result_category(::location::nearby::proto::connections::OperationResultCategory value);
+  public:
+
+  // optional .location.nearby.proto.connections.OperationResultCode result_code = 2;
+  bool has_result_code() const;
+  private:
+  bool _internal_has_result_code() const;
+  public:
+  void clear_result_code();
+  ::location::nearby::proto::connections::OperationResultCode result_code() const;
+  void set_result_code(::location::nearby::proto::connections::OperationResultCode value);
+  private:
+  ::location::nearby::proto::connections::OperationResultCode _internal_result_code() const;
+  void _internal_set_result_code(::location::nearby::proto::connections::OperationResultCode value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:location.nearby.analytics.proto.ConnectionsLog.OperationResult)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  int result_category_;
+  int result_code_;
+  friend struct ::TableStruct_internal_2fproto_2fanalytics_2fconnections_5flog_2eproto;
+};
+// -------------------------------------------------------------------
+
 class ConnectionsLog_StrategySession final :
     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.analytics.proto.ConnectionsLog.StrategySession) */ {
  public:
@@ -401,7 +562,7 @@ class ConnectionsLog_StrategySession final :
                &_ConnectionsLog_StrategySession_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    1;
+    2;
 
   friend void swap(ConnectionsLog_StrategySession& a, ConnectionsLog_StrategySession& b) {
     a.Swap(&b);
@@ -697,7 +858,7 @@ class ConnectionsLog_DiscoveryPhase final :
                &_ConnectionsLog_DiscoveryPhase_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    2;
+    3;
 
   friend void swap(ConnectionsLog_DiscoveryPhase& a, ConnectionsLog_DiscoveryPhase& b) {
     a.Swap(&b);
@@ -953,7 +1114,7 @@ class ConnectionsLog_DiscoveredEndpoint final :
                &_ConnectionsLog_DiscoveredEndpoint_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    3;
+    4;
 
   friend void swap(ConnectionsLog_DiscoveredEndpoint& a, ConnectionsLog_DiscoveredEndpoint& b) {
     a.Swap(&b);
@@ -1110,7 +1271,7 @@ class ConnectionsLog_UwbRangingProcess final :
                &_ConnectionsLog_UwbRangingProcess_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    4;
+    5;
 
   friend void swap(ConnectionsLog_UwbRangingProcess& a, ConnectionsLog_UwbRangingProcess& b) {
     a.Swap(&b);
@@ -1407,7 +1568,7 @@ class ConnectionsLog_RawUwbRangingEvent final :
                &_ConnectionsLog_RawUwbRangingEvent_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    5;
+    6;
 
   friend void swap(ConnectionsLog_RawUwbRangingEvent& a, ConnectionsLog_RawUwbRangingEvent& b) {
     a.Swap(&b);
@@ -1579,7 +1740,7 @@ class ConnectionsLog_AdvertisingPhase final :
                &_ConnectionsLog_AdvertisingPhase_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    6;
+    7;
 
   friend void swap(ConnectionsLog_AdvertisingPhase& a, ConnectionsLog_AdvertisingPhase& b) {
     a.Swap(&b);
@@ -1795,7 +1956,7 @@ class ConnectionsLog_ConnectionRequest final :
                &_ConnectionsLog_ConnectionRequest_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    7;
+    8;
 
   friend void swap(ConnectionsLog_ConnectionRequest& a, ConnectionsLog_ConnectionRequest& b) {
     a.Swap(&b);
@@ -1997,7 +2158,7 @@ class ConnectionsLog_ConnectionAttempt final :
                &_ConnectionsLog_ConnectionAttempt_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    8;
+    9;
 
   friend void swap(ConnectionsLog_ConnectionAttempt& a, ConnectionsLog_ConnectionAttempt& b) {
     a.Swap(&b);
@@ -2066,6 +2227,7 @@ class ConnectionsLog_ConnectionAttempt final :
   enum : int {
     kConnectionTokenFieldNumber = 7,
     kConnectionAttemptMetadataFieldNumber = 8,
+    kOperationResultFieldNumber = 9,
     kDurationMillisFieldNumber = 1,
     kTypeFieldNumber = 2,
     kDirectionFieldNumber = 3,
@@ -2109,6 +2271,24 @@ class ConnectionsLog_ConnectionAttempt final :
       ::location::nearby::analytics::proto::ConnectionsLog_ConnectionAttemptMetadata* connection_attempt_metadata);
   ::location::nearby::analytics::proto::ConnectionsLog_ConnectionAttemptMetadata* unsafe_arena_release_connection_attempt_metadata();
 
+  // optional .location.nearby.analytics.proto.ConnectionsLog.OperationResult operation_result = 9;
+  bool has_operation_result() const;
+  private:
+  bool _internal_has_operation_result() const;
+  public:
+  void clear_operation_result();
+  const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult& operation_result() const;
+  PROTOBUF_NODISCARD ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* release_operation_result();
+  ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* mutable_operation_result();
+  void set_allocated_operation_result(::location::nearby::analytics::proto::ConnectionsLog_OperationResult* operation_result);
+  private:
+  const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult& _internal_operation_result() const;
+  ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* _internal_mutable_operation_result();
+  public:
+  void unsafe_arena_set_allocated_operation_result(
+      ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* operation_result);
+  ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* unsafe_arena_release_operation_result();
+
   // optional int64 duration_millis = 1;
   bool has_duration_millis() const;
   private:
@@ -2198,6 +2378,7 @@ class ConnectionsLog_ConnectionAttempt final :
   mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr connection_token_;
   ::location::nearby::analytics::proto::ConnectionsLog_ConnectionAttemptMetadata* connection_attempt_metadata_;
+  ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* operation_result_;
   int64_t duration_millis_;
   int type_;
   int direction_;
@@ -2254,7 +2435,7 @@ class ConnectionsLog_EstablishedConnection final :
                &_ConnectionsLog_EstablishedConnection_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    9;
+    10;
 
   friend void swap(ConnectionsLog_EstablishedConnection& a, ConnectionsLog_EstablishedConnection& b) {
     a.Swap(&b);
@@ -2352,6 +2533,7 @@ class ConnectionsLog_EstablishedConnection final :
     kSentPayloadFieldNumber = 3,
     kReceivedPayloadFieldNumber = 4,
     kConnectionTokenFieldNumber = 7,
+    kOperationResultFieldNumber = 10,
     kDurationMillisFieldNumber = 1,
     kMediumFieldNumber = 2,
     kDisconnectionReasonFieldNumber = 5,
@@ -2413,6 +2595,24 @@ class ConnectionsLog_EstablishedConnection final :
   std::string* _internal_mutable_connection_token();
   public:
 
+  // optional .location.nearby.analytics.proto.ConnectionsLog.OperationResult operation_result = 10;
+  bool has_operation_result() const;
+  private:
+  bool _internal_has_operation_result() const;
+  public:
+  void clear_operation_result();
+  const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult& operation_result() const;
+  PROTOBUF_NODISCARD ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* release_operation_result();
+  ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* mutable_operation_result();
+  void set_allocated_operation_result(::location::nearby::analytics::proto::ConnectionsLog_OperationResult* operation_result);
+  private:
+  const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult& _internal_operation_result() const;
+  ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* _internal_mutable_operation_result();
+  public:
+  void unsafe_arena_set_allocated_operation_result(
+      ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* operation_result);
+  ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* unsafe_arena_release_operation_result();
+
   // optional int64 duration_millis = 1;
   bool has_duration_millis() const;
   private:
@@ -2503,6 +2703,7 @@ class ConnectionsLog_EstablishedConnection final :
   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::location::nearby::analytics::proto::ConnectionsLog_Payload > sent_payload_;
   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::location::nearby::analytics::proto::ConnectionsLog_Payload > received_payload_;
   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr connection_token_;
+  ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* operation_result_;
   int64_t duration_millis_;
   int medium_;
   int disconnection_reason_;
@@ -2559,7 +2760,7 @@ class ConnectionsLog_Payload final :
                &_ConnectionsLog_Payload_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    10;
+    11;
 
   friend void swap(ConnectionsLog_Payload& a, ConnectionsLog_Payload& b) {
     a.Swap(&b);
@@ -2626,6 +2827,7 @@ class ConnectionsLog_Payload final :
   // accessors -------------------------------------------------------
 
   enum : int {
+    kOperationResultFieldNumber = 8,
     kDurationMillisFieldNumber = 1,
     kTotalSizeBytesFieldNumber = 3,
     kTypeFieldNumber = 2,
@@ -2634,6 +2836,24 @@ class ConnectionsLog_Payload final :
     kStatusFieldNumber = 6,
     kNumSuccessfulAutoResumeFieldNumber = 7,
   };
+  // optional .location.nearby.analytics.proto.ConnectionsLog.OperationResult operation_result = 8;
+  bool has_operation_result() const;
+  private:
+  bool _internal_has_operation_result() const;
+  public:
+  void clear_operation_result();
+  const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult& operation_result() const;
+  PROTOBUF_NODISCARD ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* release_operation_result();
+  ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* mutable_operation_result();
+  void set_allocated_operation_result(::location::nearby::analytics::proto::ConnectionsLog_OperationResult* operation_result);
+  private:
+  const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult& _internal_operation_result() const;
+  ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* _internal_mutable_operation_result();
+  public:
+  void unsafe_arena_set_allocated_operation_result(
+      ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* operation_result);
+  ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* unsafe_arena_release_operation_result();
+
   // optional int64 duration_millis = 1;
   bool has_duration_millis() const;
   private:
@@ -2734,6 +2954,7 @@ class ConnectionsLog_Payload final :
   typedef void DestructorSkippable_;
   ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
   mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* operation_result_;
   int64_t duration_millis_;
   int64_t total_size_bytes_;
   int type_;
@@ -2791,7 +3012,7 @@ class ConnectionsLog_BandwidthUpgradeAttempt final :
                &_ConnectionsLog_BandwidthUpgradeAttempt_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    11;
+    12;
 
   friend void swap(ConnectionsLog_BandwidthUpgradeAttempt& a, ConnectionsLog_BandwidthUpgradeAttempt& b) {
     a.Swap(&b);
@@ -2859,6 +3080,7 @@ class ConnectionsLog_BandwidthUpgradeAttempt final :
 
   enum : int {
     kConnectionTokenFieldNumber = 8,
+    kOperationResultFieldNumber = 9,
     kDurationMillisFieldNumber = 2,
     kDirectionFieldNumber = 1,
     kFromMediumFieldNumber = 3,
@@ -2885,6 +3107,24 @@ class ConnectionsLog_BandwidthUpgradeAttempt final :
   std::string* _internal_mutable_connection_token();
   public:
 
+  // optional .location.nearby.analytics.proto.ConnectionsLog.OperationResult operation_result = 9;
+  bool has_operation_result() const;
+  private:
+  bool _internal_has_operation_result() const;
+  public:
+  void clear_operation_result();
+  const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult& operation_result() const;
+  PROTOBUF_NODISCARD ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* release_operation_result();
+  ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* mutable_operation_result();
+  void set_allocated_operation_result(::location::nearby::analytics::proto::ConnectionsLog_OperationResult* operation_result);
+  private:
+  const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult& _internal_operation_result() const;
+  ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* _internal_mutable_operation_result();
+  public:
+  void unsafe_arena_set_allocated_operation_result(
+      ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* operation_result);
+  ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* unsafe_arena_release_operation_result();
+
   // optional int64 duration_millis = 2;
   bool has_duration_millis() const;
   private:
@@ -2986,6 +3226,7 @@ class ConnectionsLog_BandwidthUpgradeAttempt final :
   ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
   mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr connection_token_;
+  ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* operation_result_;
   int64_t duration_millis_;
   int direction_;
   int from_medium_;
@@ -3061,7 +3302,7 @@ class ConnectionsLog_ErrorCode final :
                &_ConnectionsLog_ErrorCode_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    12;
+    13;
 
   friend void swap(ConnectionsLog_ErrorCode& a, ConnectionsLog_ErrorCode& b) {
     a.Swap(&b);
@@ -3538,7 +3779,7 @@ class ConnectionsLog_AdvertisingMetadata final :
                &_ConnectionsLog_AdvertisingMetadata_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    13;
+    14;
 
   friend void swap(ConnectionsLog_AdvertisingMetadata& a, ConnectionsLog_AdvertisingMetadata& b) {
     a.Swap(&b);
@@ -3755,7 +3996,7 @@ class ConnectionsLog_DiscoveryMetadata final :
                &_ConnectionsLog_DiscoveryMetadata_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    14;
+    15;
 
   friend void swap(ConnectionsLog_DiscoveryMetadata& a, ConnectionsLog_DiscoveryMetadata& b) {
     a.Swap(&b);
@@ -3942,7 +4183,7 @@ class ConnectionsLog_ConnectionAttemptMetadata final :
                &_ConnectionsLog_ConnectionAttemptMetadata_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    15;
+    16;
 
   friend void swap(ConnectionsLog_ConnectionAttemptMetadata& a, ConnectionsLog_ConnectionAttemptMetadata& b) {
     a.Swap(&b);
@@ -4304,7 +4545,7 @@ class ConnectionsLog final :
                &_ConnectionsLog_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    16;
+    17;
 
   friend void swap(ConnectionsLog& a, ConnectionsLog& b) {
     a.Swap(&b);
@@ -4369,6 +4610,7 @@ class ConnectionsLog final :
   // nested types ----------------------------------------------------
 
   typedef ConnectionsLog_ClientSession ClientSession;
+  typedef ConnectionsLog_OperationResult OperationResult;
   typedef ConnectionsLog_StrategySession StrategySession;
   typedef ConnectionsLog_DiscoveryPhase DiscoveryPhase;
   typedef ConnectionsLog_DiscoveredEndpoint DiscoveredEndpoint;
@@ -4688,6 +4930,68 @@ inline void ConnectionsLog_ClientSession::set_allocated_connection_token(std::st
 
 // -------------------------------------------------------------------
 
+// ConnectionsLog_OperationResult
+
+// optional .location.nearby.proto.connections.OperationResultCategory result_category = 1;
+inline bool ConnectionsLog_OperationResult::_internal_has_result_category() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ConnectionsLog_OperationResult::has_result_category() const {
+  return _internal_has_result_category();
+}
+inline void ConnectionsLog_OperationResult::clear_result_category() {
+  result_category_ = 0;
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::location::nearby::proto::connections::OperationResultCategory ConnectionsLog_OperationResult::_internal_result_category() const {
+  return static_cast< ::location::nearby::proto::connections::OperationResultCategory >(result_category_);
+}
+inline ::location::nearby::proto::connections::OperationResultCategory ConnectionsLog_OperationResult::result_category() const {
+  // @@protoc_insertion_point(field_get:location.nearby.analytics.proto.ConnectionsLog.OperationResult.result_category)
+  return _internal_result_category();
+}
+inline void ConnectionsLog_OperationResult::_internal_set_result_category(::location::nearby::proto::connections::OperationResultCategory value) {
+  assert(::location::nearby::proto::connections::OperationResultCategory_IsValid(value));
+  _has_bits_[0] |= 0x00000001u;
+  result_category_ = value;
+}
+inline void ConnectionsLog_OperationResult::set_result_category(::location::nearby::proto::connections::OperationResultCategory value) {
+  _internal_set_result_category(value);
+  // @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.OperationResult.result_category)
+}
+
+// optional .location.nearby.proto.connections.OperationResultCode result_code = 2;
+inline bool ConnectionsLog_OperationResult::_internal_has_result_code() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ConnectionsLog_OperationResult::has_result_code() const {
+  return _internal_has_result_code();
+}
+inline void ConnectionsLog_OperationResult::clear_result_code() {
+  result_code_ = 0;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::location::nearby::proto::connections::OperationResultCode ConnectionsLog_OperationResult::_internal_result_code() const {
+  return static_cast< ::location::nearby::proto::connections::OperationResultCode >(result_code_);
+}
+inline ::location::nearby::proto::connections::OperationResultCode ConnectionsLog_OperationResult::result_code() const {
+  // @@protoc_insertion_point(field_get:location.nearby.analytics.proto.ConnectionsLog.OperationResult.result_code)
+  return _internal_result_code();
+}
+inline void ConnectionsLog_OperationResult::_internal_set_result_code(::location::nearby::proto::connections::OperationResultCode value) {
+  assert(::location::nearby::proto::connections::OperationResultCode_IsValid(value));
+  _has_bits_[0] |= 0x00000002u;
+  result_code_ = value;
+}
+inline void ConnectionsLog_OperationResult::set_result_code(::location::nearby::proto::connections::OperationResultCode value) {
+  _internal_set_result_code(value);
+  // @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.OperationResult.result_code)
+}
+
+// -------------------------------------------------------------------
+
 // ConnectionsLog_StrategySession
 
 // optional int64 duration_millis = 1;
@@ -6236,7 +6540,7 @@ inline void ConnectionsLog_ConnectionRequest::set_client_flow_id(int64_t value)
 
 // optional int64 duration_millis = 1;
 inline bool ConnectionsLog_ConnectionAttempt::_internal_has_duration_millis() const {
-  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
   return value;
 }
 inline bool ConnectionsLog_ConnectionAttempt::has_duration_millis() const {
@@ -6244,7 +6548,7 @@ inline bool ConnectionsLog_ConnectionAttempt::has_duration_millis() const {
 }
 inline void ConnectionsLog_ConnectionAttempt::clear_duration_millis() {
   duration_millis_ = int64_t{0};
-  _has_bits_[0] &= ~0x00000004u;
+  _has_bits_[0] &= ~0x00000008u;
 }
 inline int64_t ConnectionsLog_ConnectionAttempt::_internal_duration_millis() const {
   return duration_millis_;
@@ -6254,7 +6558,7 @@ inline int64_t ConnectionsLog_ConnectionAttempt::duration_millis() const {
   return _internal_duration_millis();
 }
 inline void ConnectionsLog_ConnectionAttempt::_internal_set_duration_millis(int64_t value) {
-  _has_bits_[0] |= 0x00000004u;
+  _has_bits_[0] |= 0x00000008u;
   duration_millis_ = value;
 }
 inline void ConnectionsLog_ConnectionAttempt::set_duration_millis(int64_t value) {
@@ -6264,7 +6568,7 @@ inline void ConnectionsLog_ConnectionAttempt::set_duration_millis(int64_t value)
 
 // optional .location.nearby.proto.connections.ConnectionAttemptType type = 2;
 inline bool ConnectionsLog_ConnectionAttempt::_internal_has_type() const {
-  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
   return value;
 }
 inline bool ConnectionsLog_ConnectionAttempt::has_type() const {
@@ -6272,7 +6576,7 @@ inline bool ConnectionsLog_ConnectionAttempt::has_type() const {
 }
 inline void ConnectionsLog_ConnectionAttempt::clear_type() {
   type_ = 0;
-  _has_bits_[0] &= ~0x00000008u;
+  _has_bits_[0] &= ~0x00000010u;
 }
 inline ::location::nearby::proto::connections::ConnectionAttemptType ConnectionsLog_ConnectionAttempt::_internal_type() const {
   return static_cast< ::location::nearby::proto::connections::ConnectionAttemptType >(type_);
@@ -6283,7 +6587,7 @@ inline ::location::nearby::proto::connections::ConnectionAttemptType Connections
 }
 inline void ConnectionsLog_ConnectionAttempt::_internal_set_type(::location::nearby::proto::connections::ConnectionAttemptType value) {
   assert(::location::nearby::proto::connections::ConnectionAttemptType_IsValid(value));
-  _has_bits_[0] |= 0x00000008u;
+  _has_bits_[0] |= 0x00000010u;
   type_ = value;
 }
 inline void ConnectionsLog_ConnectionAttempt::set_type(::location::nearby::proto::connections::ConnectionAttemptType value) {
@@ -6293,7 +6597,7 @@ inline void ConnectionsLog_ConnectionAttempt::set_type(::location::nearby::proto
 
 // optional .location.nearby.proto.connections.ConnectionAttemptDirection direction = 3;
 inline bool ConnectionsLog_ConnectionAttempt::_internal_has_direction() const {
-  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
   return value;
 }
 inline bool ConnectionsLog_ConnectionAttempt::has_direction() const {
@@ -6301,7 +6605,7 @@ inline bool ConnectionsLog_ConnectionAttempt::has_direction() const {
 }
 inline void ConnectionsLog_ConnectionAttempt::clear_direction() {
   direction_ = 0;
-  _has_bits_[0] &= ~0x00000010u;
+  _has_bits_[0] &= ~0x00000020u;
 }
 inline ::location::nearby::proto::connections::ConnectionAttemptDirection ConnectionsLog_ConnectionAttempt::_internal_direction() const {
   return static_cast< ::location::nearby::proto::connections::ConnectionAttemptDirection >(direction_);
@@ -6312,7 +6616,7 @@ inline ::location::nearby::proto::connections::ConnectionAttemptDirection Connec
 }
 inline void ConnectionsLog_ConnectionAttempt::_internal_set_direction(::location::nearby::proto::connections::ConnectionAttemptDirection value) {
   assert(::location::nearby::proto::connections::ConnectionAttemptDirection_IsValid(value));
-  _has_bits_[0] |= 0x00000010u;
+  _has_bits_[0] |= 0x00000020u;
   direction_ = value;
 }
 inline void ConnectionsLog_ConnectionAttempt::set_direction(::location::nearby::proto::connections::ConnectionAttemptDirection value) {
@@ -6322,7 +6626,7 @@ inline void ConnectionsLog_ConnectionAttempt::set_direction(::location::nearby::
 
 // optional .location.nearby.proto.connections.Medium medium = 4;
 inline bool ConnectionsLog_ConnectionAttempt::_internal_has_medium() const {
-  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
   return value;
 }
 inline bool ConnectionsLog_ConnectionAttempt::has_medium() const {
@@ -6330,7 +6634,7 @@ inline bool ConnectionsLog_ConnectionAttempt::has_medium() const {
 }
 inline void ConnectionsLog_ConnectionAttempt::clear_medium() {
   medium_ = 0;
-  _has_bits_[0] &= ~0x00000020u;
+  _has_bits_[0] &= ~0x00000040u;
 }
 inline ::location::nearby::proto::connections::Medium ConnectionsLog_ConnectionAttempt::_internal_medium() const {
   return static_cast< ::location::nearby::proto::connections::Medium >(medium_);
@@ -6341,7 +6645,7 @@ inline ::location::nearby::proto::connections::Medium ConnectionsLog_ConnectionA
 }
 inline void ConnectionsLog_ConnectionAttempt::_internal_set_medium(::location::nearby::proto::connections::Medium value) {
   assert(::location::nearby::proto::connections::Medium_IsValid(value));
-  _has_bits_[0] |= 0x00000020u;
+  _has_bits_[0] |= 0x00000040u;
   medium_ = value;
 }
 inline void ConnectionsLog_ConnectionAttempt::set_medium(::location::nearby::proto::connections::Medium value) {
@@ -6351,7 +6655,7 @@ inline void ConnectionsLog_ConnectionAttempt::set_medium(::location::nearby::pro
 
 // optional .location.nearby.proto.connections.ConnectionAttemptResult attempt_result = 5;
 inline bool ConnectionsLog_ConnectionAttempt::_internal_has_attempt_result() const {
-  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
   return value;
 }
 inline bool ConnectionsLog_ConnectionAttempt::has_attempt_result() const {
@@ -6359,7 +6663,7 @@ inline bool ConnectionsLog_ConnectionAttempt::has_attempt_result() const {
 }
 inline void ConnectionsLog_ConnectionAttempt::clear_attempt_result() {
   attempt_result_ = 0;
-  _has_bits_[0] &= ~0x00000040u;
+  _has_bits_[0] &= ~0x00000080u;
 }
 inline ::location::nearby::proto::connections::ConnectionAttemptResult ConnectionsLog_ConnectionAttempt::_internal_attempt_result() const {
   return static_cast< ::location::nearby::proto::connections::ConnectionAttemptResult >(attempt_result_);
@@ -6370,7 +6674,7 @@ inline ::location::nearby::proto::connections::ConnectionAttemptResult Connectio
 }
 inline void ConnectionsLog_ConnectionAttempt::_internal_set_attempt_result(::location::nearby::proto::connections::ConnectionAttemptResult value) {
   assert(::location::nearby::proto::connections::ConnectionAttemptResult_IsValid(value));
-  _has_bits_[0] |= 0x00000040u;
+  _has_bits_[0] |= 0x00000080u;
   attempt_result_ = value;
 }
 inline void ConnectionsLog_ConnectionAttempt::set_attempt_result(::location::nearby::proto::connections::ConnectionAttemptResult value) {
@@ -6380,7 +6684,7 @@ inline void ConnectionsLog_ConnectionAttempt::set_attempt_result(::location::nea
 
 // optional int64 client_flow_id = 6;
 inline bool ConnectionsLog_ConnectionAttempt::_internal_has_client_flow_id() const {
-  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  bool value = (_has_bits_[0] & 0x00000100u) != 0;
   return value;
 }
 inline bool ConnectionsLog_ConnectionAttempt::has_client_flow_id() const {
@@ -6388,7 +6692,7 @@ inline bool ConnectionsLog_ConnectionAttempt::has_client_flow_id() const {
 }
 inline void ConnectionsLog_ConnectionAttempt::clear_client_flow_id() {
   client_flow_id_ = int64_t{0};
-  _has_bits_[0] &= ~0x00000080u;
+  _has_bits_[0] &= ~0x00000100u;
 }
 inline int64_t ConnectionsLog_ConnectionAttempt::_internal_client_flow_id() const {
   return client_flow_id_;
@@ -6398,7 +6702,7 @@ inline int64_t ConnectionsLog_ConnectionAttempt::client_flow_id() const {
   return _internal_client_flow_id();
 }
 inline void ConnectionsLog_ConnectionAttempt::_internal_set_client_flow_id(int64_t value) {
-  _has_bits_[0] |= 0x00000080u;
+  _has_bits_[0] |= 0x00000100u;
   client_flow_id_ = value;
 }
 inline void ConnectionsLog_ConnectionAttempt::set_client_flow_id(int64_t value) {
@@ -6565,13 +6869,103 @@ inline void ConnectionsLog_ConnectionAttempt::set_allocated_connection_attempt_m
   // @@protoc_insertion_point(field_set_allocated:location.nearby.analytics.proto.ConnectionsLog.ConnectionAttempt.connection_attempt_metadata)
 }
 
+// optional .location.nearby.analytics.proto.ConnectionsLog.OperationResult operation_result = 9;
+inline bool ConnectionsLog_ConnectionAttempt::_internal_has_operation_result() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || operation_result_ != nullptr);
+  return value;
+}
+inline bool ConnectionsLog_ConnectionAttempt::has_operation_result() const {
+  return _internal_has_operation_result();
+}
+inline void ConnectionsLog_ConnectionAttempt::clear_operation_result() {
+  if (operation_result_ != nullptr) operation_result_->Clear();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult& ConnectionsLog_ConnectionAttempt::_internal_operation_result() const {
+  const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* p = operation_result_;
+  return p != nullptr ? *p : reinterpret_cast<const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult&>(
+      ::location::nearby::analytics::proto::_ConnectionsLog_OperationResult_default_instance_);
+}
+inline const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult& ConnectionsLog_ConnectionAttempt::operation_result() const {
+  // @@protoc_insertion_point(field_get:location.nearby.analytics.proto.ConnectionsLog.ConnectionAttempt.operation_result)
+  return _internal_operation_result();
+}
+inline void ConnectionsLog_ConnectionAttempt::unsafe_arena_set_allocated_operation_result(
+    ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* operation_result) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(operation_result_);
+  }
+  operation_result_ = operation_result;
+  if (operation_result) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.analytics.proto.ConnectionsLog.ConnectionAttempt.operation_result)
+}
+inline ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* ConnectionsLog_ConnectionAttempt::release_operation_result() {
+  _has_bits_[0] &= ~0x00000004u;
+  ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* temp = operation_result_;
+  operation_result_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* ConnectionsLog_ConnectionAttempt::unsafe_arena_release_operation_result() {
+  // @@protoc_insertion_point(field_release:location.nearby.analytics.proto.ConnectionsLog.ConnectionAttempt.operation_result)
+  _has_bits_[0] &= ~0x00000004u;
+  ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* temp = operation_result_;
+  operation_result_ = nullptr;
+  return temp;
+}
+inline ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* ConnectionsLog_ConnectionAttempt::_internal_mutable_operation_result() {
+  _has_bits_[0] |= 0x00000004u;
+  if (operation_result_ == nullptr) {
+    auto* p = CreateMaybeMessage<::location::nearby::analytics::proto::ConnectionsLog_OperationResult>(GetArenaForAllocation());
+    operation_result_ = p;
+  }
+  return operation_result_;
+}
+inline ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* ConnectionsLog_ConnectionAttempt::mutable_operation_result() {
+  ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* _msg = _internal_mutable_operation_result();
+  // @@protoc_insertion_point(field_mutable:location.nearby.analytics.proto.ConnectionsLog.ConnectionAttempt.operation_result)
+  return _msg;
+}
+inline void ConnectionsLog_ConnectionAttempt::set_allocated_operation_result(::location::nearby::analytics::proto::ConnectionsLog_OperationResult* operation_result) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete operation_result_;
+  }
+  if (operation_result) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::analytics::proto::ConnectionsLog_OperationResult>::GetOwningArena(operation_result);
+    if (message_arena != submessage_arena) {
+      operation_result = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, operation_result, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  operation_result_ = operation_result;
+  // @@protoc_insertion_point(field_set_allocated:location.nearby.analytics.proto.ConnectionsLog.ConnectionAttempt.operation_result)
+}
+
 // -------------------------------------------------------------------
 
 // ConnectionsLog_EstablishedConnection
 
 // optional int64 duration_millis = 1;
 inline bool ConnectionsLog_EstablishedConnection::_internal_has_duration_millis() const {
-  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
   return value;
 }
 inline bool ConnectionsLog_EstablishedConnection::has_duration_millis() const {
@@ -6579,7 +6973,7 @@ inline bool ConnectionsLog_EstablishedConnection::has_duration_millis() const {
 }
 inline void ConnectionsLog_EstablishedConnection::clear_duration_millis() {
   duration_millis_ = int64_t{0};
-  _has_bits_[0] &= ~0x00000002u;
+  _has_bits_[0] &= ~0x00000004u;
 }
 inline int64_t ConnectionsLog_EstablishedConnection::_internal_duration_millis() const {
   return duration_millis_;
@@ -6589,7 +6983,7 @@ inline int64_t ConnectionsLog_EstablishedConnection::duration_millis() const {
   return _internal_duration_millis();
 }
 inline void ConnectionsLog_EstablishedConnection::_internal_set_duration_millis(int64_t value) {
-  _has_bits_[0] |= 0x00000002u;
+  _has_bits_[0] |= 0x00000004u;
   duration_millis_ = value;
 }
 inline void ConnectionsLog_EstablishedConnection::set_duration_millis(int64_t value) {
@@ -6599,7 +6993,7 @@ inline void ConnectionsLog_EstablishedConnection::set_duration_millis(int64_t va
 
 // optional .location.nearby.proto.connections.Medium medium = 2;
 inline bool ConnectionsLog_EstablishedConnection::_internal_has_medium() const {
-  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
   return value;
 }
 inline bool ConnectionsLog_EstablishedConnection::has_medium() const {
@@ -6607,7 +7001,7 @@ inline bool ConnectionsLog_EstablishedConnection::has_medium() const {
 }
 inline void ConnectionsLog_EstablishedConnection::clear_medium() {
   medium_ = 0;
-  _has_bits_[0] &= ~0x00000004u;
+  _has_bits_[0] &= ~0x00000008u;
 }
 inline ::location::nearby::proto::connections::Medium ConnectionsLog_EstablishedConnection::_internal_medium() const {
   return static_cast< ::location::nearby::proto::connections::Medium >(medium_);
@@ -6618,7 +7012,7 @@ inline ::location::nearby::proto::connections::Medium ConnectionsLog_Established
 }
 inline void ConnectionsLog_EstablishedConnection::_internal_set_medium(::location::nearby::proto::connections::Medium value) {
   assert(::location::nearby::proto::connections::Medium_IsValid(value));
-  _has_bits_[0] |= 0x00000004u;
+  _has_bits_[0] |= 0x00000008u;
   medium_ = value;
 }
 inline void ConnectionsLog_EstablishedConnection::set_medium(::location::nearby::proto::connections::Medium value) {
@@ -6708,7 +7102,7 @@ ConnectionsLog_EstablishedConnection::received_payload() const {
 
 // optional .location.nearby.proto.connections.DisconnectionReason disconnection_reason = 5;
 inline bool ConnectionsLog_EstablishedConnection::_internal_has_disconnection_reason() const {
-  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
   return value;
 }
 inline bool ConnectionsLog_EstablishedConnection::has_disconnection_reason() const {
@@ -6716,7 +7110,7 @@ inline bool ConnectionsLog_EstablishedConnection::has_disconnection_reason() con
 }
 inline void ConnectionsLog_EstablishedConnection::clear_disconnection_reason() {
   disconnection_reason_ = 0;
-  _has_bits_[0] &= ~0x00000008u;
+  _has_bits_[0] &= ~0x00000010u;
 }
 inline ::location::nearby::proto::connections::DisconnectionReason ConnectionsLog_EstablishedConnection::_internal_disconnection_reason() const {
   return static_cast< ::location::nearby::proto::connections::DisconnectionReason >(disconnection_reason_);
@@ -6727,7 +7121,7 @@ inline ::location::nearby::proto::connections::DisconnectionReason ConnectionsLo
 }
 inline void ConnectionsLog_EstablishedConnection::_internal_set_disconnection_reason(::location::nearby::proto::connections::DisconnectionReason value) {
   assert(::location::nearby::proto::connections::DisconnectionReason_IsValid(value));
-  _has_bits_[0] |= 0x00000008u;
+  _has_bits_[0] |= 0x00000010u;
   disconnection_reason_ = value;
 }
 inline void ConnectionsLog_EstablishedConnection::set_disconnection_reason(::location::nearby::proto::connections::DisconnectionReason value) {
@@ -6737,7 +7131,7 @@ inline void ConnectionsLog_EstablishedConnection::set_disconnection_reason(::loc
 
 // optional int64 client_flow_id = 6;
 inline bool ConnectionsLog_EstablishedConnection::_internal_has_client_flow_id() const {
-  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
   return value;
 }
 inline bool ConnectionsLog_EstablishedConnection::has_client_flow_id() const {
@@ -6745,7 +7139,7 @@ inline bool ConnectionsLog_EstablishedConnection::has_client_flow_id() const {
 }
 inline void ConnectionsLog_EstablishedConnection::clear_client_flow_id() {
   client_flow_id_ = int64_t{0};
-  _has_bits_[0] &= ~0x00000010u;
+  _has_bits_[0] &= ~0x00000020u;
 }
 inline int64_t ConnectionsLog_EstablishedConnection::_internal_client_flow_id() const {
   return client_flow_id_;
@@ -6755,7 +7149,7 @@ inline int64_t ConnectionsLog_EstablishedConnection::client_flow_id() const {
   return _internal_client_flow_id();
 }
 inline void ConnectionsLog_EstablishedConnection::_internal_set_client_flow_id(int64_t value) {
-  _has_bits_[0] |= 0x00000010u;
+  _has_bits_[0] |= 0x00000020u;
   client_flow_id_ = value;
 }
 inline void ConnectionsLog_EstablishedConnection::set_client_flow_id(int64_t value) {
@@ -6834,7 +7228,7 @@ inline void ConnectionsLog_EstablishedConnection::set_allocated_connection_token
 
 // optional .location.nearby.proto.connections.ConnectionAttemptType type = 8;
 inline bool ConnectionsLog_EstablishedConnection::_internal_has_type() const {
-  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
   return value;
 }
 inline bool ConnectionsLog_EstablishedConnection::has_type() const {
@@ -6842,7 +7236,7 @@ inline bool ConnectionsLog_EstablishedConnection::has_type() const {
 }
 inline void ConnectionsLog_EstablishedConnection::clear_type() {
   type_ = 0;
-  _has_bits_[0] &= ~0x00000020u;
+  _has_bits_[0] &= ~0x00000040u;
 }
 inline ::location::nearby::proto::connections::ConnectionAttemptType ConnectionsLog_EstablishedConnection::_internal_type() const {
   return static_cast< ::location::nearby::proto::connections::ConnectionAttemptType >(type_);
@@ -6853,7 +7247,7 @@ inline ::location::nearby::proto::connections::ConnectionAttemptType Connections
 }
 inline void ConnectionsLog_EstablishedConnection::_internal_set_type(::location::nearby::proto::connections::ConnectionAttemptType value) {
   assert(::location::nearby::proto::connections::ConnectionAttemptType_IsValid(value));
-  _has_bits_[0] |= 0x00000020u;
+  _has_bits_[0] |= 0x00000040u;
   type_ = value;
 }
 inline void ConnectionsLog_EstablishedConnection::set_type(::location::nearby::proto::connections::ConnectionAttemptType value) {
@@ -6863,7 +7257,7 @@ inline void ConnectionsLog_EstablishedConnection::set_type(::location::nearby::p
 
 // optional .location.nearby.analytics.proto.ConnectionsLog.EstablishedConnection.SafeDisconnectionResult safe_disconnection_result = 9;
 inline bool ConnectionsLog_EstablishedConnection::_internal_has_safe_disconnection_result() const {
-  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
   return value;
 }
 inline bool ConnectionsLog_EstablishedConnection::has_safe_disconnection_result() const {
@@ -6871,7 +7265,7 @@ inline bool ConnectionsLog_EstablishedConnection::has_safe_disconnection_result(
 }
 inline void ConnectionsLog_EstablishedConnection::clear_safe_disconnection_result() {
   safe_disconnection_result_ = 0;
-  _has_bits_[0] &= ~0x00000040u;
+  _has_bits_[0] &= ~0x00000080u;
 }
 inline ::location::nearby::analytics::proto::ConnectionsLog_EstablishedConnection_SafeDisconnectionResult ConnectionsLog_EstablishedConnection::_internal_safe_disconnection_result() const {
   return static_cast< ::location::nearby::analytics::proto::ConnectionsLog_EstablishedConnection_SafeDisconnectionResult >(safe_disconnection_result_);
@@ -6882,7 +7276,7 @@ inline ::location::nearby::analytics::proto::ConnectionsLog_EstablishedConnectio
 }
 inline void ConnectionsLog_EstablishedConnection::_internal_set_safe_disconnection_result(::location::nearby::analytics::proto::ConnectionsLog_EstablishedConnection_SafeDisconnectionResult value) {
   assert(::location::nearby::analytics::proto::ConnectionsLog_EstablishedConnection_SafeDisconnectionResult_IsValid(value));
-  _has_bits_[0] |= 0x00000040u;
+  _has_bits_[0] |= 0x00000080u;
   safe_disconnection_result_ = value;
 }
 inline void ConnectionsLog_EstablishedConnection::set_safe_disconnection_result(::location::nearby::analytics::proto::ConnectionsLog_EstablishedConnection_SafeDisconnectionResult value) {
@@ -6890,13 +7284,103 @@ inline void ConnectionsLog_EstablishedConnection::set_safe_disconnection_result(
   // @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.EstablishedConnection.safe_disconnection_result)
 }
 
+// optional .location.nearby.analytics.proto.ConnectionsLog.OperationResult operation_result = 10;
+inline bool ConnectionsLog_EstablishedConnection::_internal_has_operation_result() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || operation_result_ != nullptr);
+  return value;
+}
+inline bool ConnectionsLog_EstablishedConnection::has_operation_result() const {
+  return _internal_has_operation_result();
+}
+inline void ConnectionsLog_EstablishedConnection::clear_operation_result() {
+  if (operation_result_ != nullptr) operation_result_->Clear();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult& ConnectionsLog_EstablishedConnection::_internal_operation_result() const {
+  const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* p = operation_result_;
+  return p != nullptr ? *p : reinterpret_cast<const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult&>(
+      ::location::nearby::analytics::proto::_ConnectionsLog_OperationResult_default_instance_);
+}
+inline const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult& ConnectionsLog_EstablishedConnection::operation_result() const {
+  // @@protoc_insertion_point(field_get:location.nearby.analytics.proto.ConnectionsLog.EstablishedConnection.operation_result)
+  return _internal_operation_result();
+}
+inline void ConnectionsLog_EstablishedConnection::unsafe_arena_set_allocated_operation_result(
+    ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* operation_result) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(operation_result_);
+  }
+  operation_result_ = operation_result;
+  if (operation_result) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.analytics.proto.ConnectionsLog.EstablishedConnection.operation_result)
+}
+inline ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* ConnectionsLog_EstablishedConnection::release_operation_result() {
+  _has_bits_[0] &= ~0x00000002u;
+  ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* temp = operation_result_;
+  operation_result_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* ConnectionsLog_EstablishedConnection::unsafe_arena_release_operation_result() {
+  // @@protoc_insertion_point(field_release:location.nearby.analytics.proto.ConnectionsLog.EstablishedConnection.operation_result)
+  _has_bits_[0] &= ~0x00000002u;
+  ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* temp = operation_result_;
+  operation_result_ = nullptr;
+  return temp;
+}
+inline ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* ConnectionsLog_EstablishedConnection::_internal_mutable_operation_result() {
+  _has_bits_[0] |= 0x00000002u;
+  if (operation_result_ == nullptr) {
+    auto* p = CreateMaybeMessage<::location::nearby::analytics::proto::ConnectionsLog_OperationResult>(GetArenaForAllocation());
+    operation_result_ = p;
+  }
+  return operation_result_;
+}
+inline ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* ConnectionsLog_EstablishedConnection::mutable_operation_result() {
+  ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* _msg = _internal_mutable_operation_result();
+  // @@protoc_insertion_point(field_mutable:location.nearby.analytics.proto.ConnectionsLog.EstablishedConnection.operation_result)
+  return _msg;
+}
+inline void ConnectionsLog_EstablishedConnection::set_allocated_operation_result(::location::nearby::analytics::proto::ConnectionsLog_OperationResult* operation_result) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete operation_result_;
+  }
+  if (operation_result) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::analytics::proto::ConnectionsLog_OperationResult>::GetOwningArena(operation_result);
+    if (message_arena != submessage_arena) {
+      operation_result = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, operation_result, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  operation_result_ = operation_result;
+  // @@protoc_insertion_point(field_set_allocated:location.nearby.analytics.proto.ConnectionsLog.EstablishedConnection.operation_result)
+}
+
 // -------------------------------------------------------------------
 
 // ConnectionsLog_Payload
 
 // optional int64 duration_millis = 1;
 inline bool ConnectionsLog_Payload::_internal_has_duration_millis() const {
-  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
   return value;
 }
 inline bool ConnectionsLog_Payload::has_duration_millis() const {
@@ -6904,7 +7388,7 @@ inline bool ConnectionsLog_Payload::has_duration_millis() const {
 }
 inline void ConnectionsLog_Payload::clear_duration_millis() {
   duration_millis_ = int64_t{0};
-  _has_bits_[0] &= ~0x00000001u;
+  _has_bits_[0] &= ~0x00000002u;
 }
 inline int64_t ConnectionsLog_Payload::_internal_duration_millis() const {
   return duration_millis_;
@@ -6914,7 +7398,7 @@ inline int64_t ConnectionsLog_Payload::duration_millis() const {
   return _internal_duration_millis();
 }
 inline void ConnectionsLog_Payload::_internal_set_duration_millis(int64_t value) {
-  _has_bits_[0] |= 0x00000001u;
+  _has_bits_[0] |= 0x00000002u;
   duration_millis_ = value;
 }
 inline void ConnectionsLog_Payload::set_duration_millis(int64_t value) {
@@ -6924,7 +7408,7 @@ inline void ConnectionsLog_Payload::set_duration_millis(int64_t value) {
 
 // optional .location.nearby.proto.connections.PayloadType type = 2;
 inline bool ConnectionsLog_Payload::_internal_has_type() const {
-  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
   return value;
 }
 inline bool ConnectionsLog_Payload::has_type() const {
@@ -6932,7 +7416,7 @@ inline bool ConnectionsLog_Payload::has_type() const {
 }
 inline void ConnectionsLog_Payload::clear_type() {
   type_ = 0;
-  _has_bits_[0] &= ~0x00000004u;
+  _has_bits_[0] &= ~0x00000008u;
 }
 inline ::location::nearby::proto::connections::PayloadType ConnectionsLog_Payload::_internal_type() const {
   return static_cast< ::location::nearby::proto::connections::PayloadType >(type_);
@@ -6943,7 +7427,7 @@ inline ::location::nearby::proto::connections::PayloadType ConnectionsLog_Payloa
 }
 inline void ConnectionsLog_Payload::_internal_set_type(::location::nearby::proto::connections::PayloadType value) {
   assert(::location::nearby::proto::connections::PayloadType_IsValid(value));
-  _has_bits_[0] |= 0x00000004u;
+  _has_bits_[0] |= 0x00000008u;
   type_ = value;
 }
 inline void ConnectionsLog_Payload::set_type(::location::nearby::proto::connections::PayloadType value) {
@@ -6953,7 +7437,7 @@ inline void ConnectionsLog_Payload::set_type(::location::nearby::proto::connecti
 
 // optional int64 total_size_bytes = 3;
 inline bool ConnectionsLog_Payload::_internal_has_total_size_bytes() const {
-  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
   return value;
 }
 inline bool ConnectionsLog_Payload::has_total_size_bytes() const {
@@ -6961,7 +7445,7 @@ inline bool ConnectionsLog_Payload::has_total_size_bytes() const {
 }
 inline void ConnectionsLog_Payload::clear_total_size_bytes() {
   total_size_bytes_ = int64_t{0};
-  _has_bits_[0] &= ~0x00000002u;
+  _has_bits_[0] &= ~0x00000004u;
 }
 inline int64_t ConnectionsLog_Payload::_internal_total_size_bytes() const {
   return total_size_bytes_;
@@ -6971,7 +7455,7 @@ inline int64_t ConnectionsLog_Payload::total_size_bytes() const {
   return _internal_total_size_bytes();
 }
 inline void ConnectionsLog_Payload::_internal_set_total_size_bytes(int64_t value) {
-  _has_bits_[0] |= 0x00000002u;
+  _has_bits_[0] |= 0x00000004u;
   total_size_bytes_ = value;
 }
 inline void ConnectionsLog_Payload::set_total_size_bytes(int64_t value) {
@@ -6981,7 +7465,7 @@ inline void ConnectionsLog_Payload::set_total_size_bytes(int64_t value) {
 
 // optional int64 num_bytes_transferred = 4;
 inline bool ConnectionsLog_Payload::_internal_has_num_bytes_transferred() const {
-  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
   return value;
 }
 inline bool ConnectionsLog_Payload::has_num_bytes_transferred() const {
@@ -6989,7 +7473,7 @@ inline bool ConnectionsLog_Payload::has_num_bytes_transferred() const {
 }
 inline void ConnectionsLog_Payload::clear_num_bytes_transferred() {
   num_bytes_transferred_ = int64_t{0};
-  _has_bits_[0] &= ~0x00000010u;
+  _has_bits_[0] &= ~0x00000020u;
 }
 inline int64_t ConnectionsLog_Payload::_internal_num_bytes_transferred() const {
   return num_bytes_transferred_;
@@ -6999,7 +7483,7 @@ inline int64_t ConnectionsLog_Payload::num_bytes_transferred() const {
   return _internal_num_bytes_transferred();
 }
 inline void ConnectionsLog_Payload::_internal_set_num_bytes_transferred(int64_t value) {
-  _has_bits_[0] |= 0x00000010u;
+  _has_bits_[0] |= 0x00000020u;
   num_bytes_transferred_ = value;
 }
 inline void ConnectionsLog_Payload::set_num_bytes_transferred(int64_t value) {
@@ -7009,7 +7493,7 @@ inline void ConnectionsLog_Payload::set_num_bytes_transferred(int64_t value) {
 
 // optional int32 num_chunks = 5;
 inline bool ConnectionsLog_Payload::_internal_has_num_chunks() const {
-  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
   return value;
 }
 inline bool ConnectionsLog_Payload::has_num_chunks() const {
@@ -7017,7 +7501,7 @@ inline bool ConnectionsLog_Payload::has_num_chunks() const {
 }
 inline void ConnectionsLog_Payload::clear_num_chunks() {
   num_chunks_ = 0;
-  _has_bits_[0] &= ~0x00000008u;
+  _has_bits_[0] &= ~0x00000010u;
 }
 inline int32_t ConnectionsLog_Payload::_internal_num_chunks() const {
   return num_chunks_;
@@ -7027,7 +7511,7 @@ inline int32_t ConnectionsLog_Payload::num_chunks() const {
   return _internal_num_chunks();
 }
 inline void ConnectionsLog_Payload::_internal_set_num_chunks(int32_t value) {
-  _has_bits_[0] |= 0x00000008u;
+  _has_bits_[0] |= 0x00000010u;
   num_chunks_ = value;
 }
 inline void ConnectionsLog_Payload::set_num_chunks(int32_t value) {
@@ -7037,7 +7521,7 @@ inline void ConnectionsLog_Payload::set_num_chunks(int32_t value) {
 
 // optional .location.nearby.proto.connections.PayloadStatus status = 6;
 inline bool ConnectionsLog_Payload::_internal_has_status() const {
-  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
   return value;
 }
 inline bool ConnectionsLog_Payload::has_status() const {
@@ -7045,7 +7529,7 @@ inline bool ConnectionsLog_Payload::has_status() const {
 }
 inline void ConnectionsLog_Payload::clear_status() {
   status_ = 0;
-  _has_bits_[0] &= ~0x00000020u;
+  _has_bits_[0] &= ~0x00000040u;
 }
 inline ::location::nearby::proto::connections::PayloadStatus ConnectionsLog_Payload::_internal_status() const {
   return static_cast< ::location::nearby::proto::connections::PayloadStatus >(status_);
@@ -7056,7 +7540,7 @@ inline ::location::nearby::proto::connections::PayloadStatus ConnectionsLog_Payl
 }
 inline void ConnectionsLog_Payload::_internal_set_status(::location::nearby::proto::connections::PayloadStatus value) {
   assert(::location::nearby::proto::connections::PayloadStatus_IsValid(value));
-  _has_bits_[0] |= 0x00000020u;
+  _has_bits_[0] |= 0x00000040u;
   status_ = value;
 }
 inline void ConnectionsLog_Payload::set_status(::location::nearby::proto::connections::PayloadStatus value) {
@@ -7066,7 +7550,7 @@ inline void ConnectionsLog_Payload::set_status(::location::nearby::proto::connec
 
 // optional int32 num_successful_auto_resume = 7;
 inline bool ConnectionsLog_Payload::_internal_has_num_successful_auto_resume() const {
-  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
   return value;
 }
 inline bool ConnectionsLog_Payload::has_num_successful_auto_resume() const {
@@ -7074,7 +7558,7 @@ inline bool ConnectionsLog_Payload::has_num_successful_auto_resume() const {
 }
 inline void ConnectionsLog_Payload::clear_num_successful_auto_resume() {
   num_successful_auto_resume_ = 0;
-  _has_bits_[0] &= ~0x00000040u;
+  _has_bits_[0] &= ~0x00000080u;
 }
 inline int32_t ConnectionsLog_Payload::_internal_num_successful_auto_resume() const {
   return num_successful_auto_resume_;
@@ -7084,7 +7568,7 @@ inline int32_t ConnectionsLog_Payload::num_successful_auto_resume() const {
   return _internal_num_successful_auto_resume();
 }
 inline void ConnectionsLog_Payload::_internal_set_num_successful_auto_resume(int32_t value) {
-  _has_bits_[0] |= 0x00000040u;
+  _has_bits_[0] |= 0x00000080u;
   num_successful_auto_resume_ = value;
 }
 inline void ConnectionsLog_Payload::set_num_successful_auto_resume(int32_t value) {
@@ -7092,13 +7576,103 @@ inline void ConnectionsLog_Payload::set_num_successful_auto_resume(int32_t value
   // @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.Payload.num_successful_auto_resume)
 }
 
+// optional .location.nearby.analytics.proto.ConnectionsLog.OperationResult operation_result = 8;
+inline bool ConnectionsLog_Payload::_internal_has_operation_result() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || operation_result_ != nullptr);
+  return value;
+}
+inline bool ConnectionsLog_Payload::has_operation_result() const {
+  return _internal_has_operation_result();
+}
+inline void ConnectionsLog_Payload::clear_operation_result() {
+  if (operation_result_ != nullptr) operation_result_->Clear();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult& ConnectionsLog_Payload::_internal_operation_result() const {
+  const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* p = operation_result_;
+  return p != nullptr ? *p : reinterpret_cast<const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult&>(
+      ::location::nearby::analytics::proto::_ConnectionsLog_OperationResult_default_instance_);
+}
+inline const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult& ConnectionsLog_Payload::operation_result() const {
+  // @@protoc_insertion_point(field_get:location.nearby.analytics.proto.ConnectionsLog.Payload.operation_result)
+  return _internal_operation_result();
+}
+inline void ConnectionsLog_Payload::unsafe_arena_set_allocated_operation_result(
+    ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* operation_result) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(operation_result_);
+  }
+  operation_result_ = operation_result;
+  if (operation_result) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.analytics.proto.ConnectionsLog.Payload.operation_result)
+}
+inline ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* ConnectionsLog_Payload::release_operation_result() {
+  _has_bits_[0] &= ~0x00000001u;
+  ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* temp = operation_result_;
+  operation_result_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* ConnectionsLog_Payload::unsafe_arena_release_operation_result() {
+  // @@protoc_insertion_point(field_release:location.nearby.analytics.proto.ConnectionsLog.Payload.operation_result)
+  _has_bits_[0] &= ~0x00000001u;
+  ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* temp = operation_result_;
+  operation_result_ = nullptr;
+  return temp;
+}
+inline ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* ConnectionsLog_Payload::_internal_mutable_operation_result() {
+  _has_bits_[0] |= 0x00000001u;
+  if (operation_result_ == nullptr) {
+    auto* p = CreateMaybeMessage<::location::nearby::analytics::proto::ConnectionsLog_OperationResult>(GetArenaForAllocation());
+    operation_result_ = p;
+  }
+  return operation_result_;
+}
+inline ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* ConnectionsLog_Payload::mutable_operation_result() {
+  ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* _msg = _internal_mutable_operation_result();
+  // @@protoc_insertion_point(field_mutable:location.nearby.analytics.proto.ConnectionsLog.Payload.operation_result)
+  return _msg;
+}
+inline void ConnectionsLog_Payload::set_allocated_operation_result(::location::nearby::analytics::proto::ConnectionsLog_OperationResult* operation_result) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete operation_result_;
+  }
+  if (operation_result) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::analytics::proto::ConnectionsLog_OperationResult>::GetOwningArena(operation_result);
+    if (message_arena != submessage_arena) {
+      operation_result = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, operation_result, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  operation_result_ = operation_result;
+  // @@protoc_insertion_point(field_set_allocated:location.nearby.analytics.proto.ConnectionsLog.Payload.operation_result)
+}
+
 // -------------------------------------------------------------------
 
 // ConnectionsLog_BandwidthUpgradeAttempt
 
 // optional .location.nearby.proto.connections.ConnectionAttemptDirection direction = 1;
 inline bool ConnectionsLog_BandwidthUpgradeAttempt::_internal_has_direction() const {
-  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
   return value;
 }
 inline bool ConnectionsLog_BandwidthUpgradeAttempt::has_direction() const {
@@ -7106,7 +7680,7 @@ inline bool ConnectionsLog_BandwidthUpgradeAttempt::has_direction() const {
 }
 inline void ConnectionsLog_BandwidthUpgradeAttempt::clear_direction() {
   direction_ = 0;
-  _has_bits_[0] &= ~0x00000004u;
+  _has_bits_[0] &= ~0x00000008u;
 }
 inline ::location::nearby::proto::connections::ConnectionAttemptDirection ConnectionsLog_BandwidthUpgradeAttempt::_internal_direction() const {
   return static_cast< ::location::nearby::proto::connections::ConnectionAttemptDirection >(direction_);
@@ -7117,7 +7691,7 @@ inline ::location::nearby::proto::connections::ConnectionAttemptDirection Connec
 }
 inline void ConnectionsLog_BandwidthUpgradeAttempt::_internal_set_direction(::location::nearby::proto::connections::ConnectionAttemptDirection value) {
   assert(::location::nearby::proto::connections::ConnectionAttemptDirection_IsValid(value));
-  _has_bits_[0] |= 0x00000004u;
+  _has_bits_[0] |= 0x00000008u;
   direction_ = value;
 }
 inline void ConnectionsLog_BandwidthUpgradeAttempt::set_direction(::location::nearby::proto::connections::ConnectionAttemptDirection value) {
@@ -7127,7 +7701,7 @@ inline void ConnectionsLog_BandwidthUpgradeAttempt::set_direction(::location::ne
 
 // optional int64 duration_millis = 2;
 inline bool ConnectionsLog_BandwidthUpgradeAttempt::_internal_has_duration_millis() const {
-  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
   return value;
 }
 inline bool ConnectionsLog_BandwidthUpgradeAttempt::has_duration_millis() const {
@@ -7135,7 +7709,7 @@ inline bool ConnectionsLog_BandwidthUpgradeAttempt::has_duration_millis() const
 }
 inline void ConnectionsLog_BandwidthUpgradeAttempt::clear_duration_millis() {
   duration_millis_ = int64_t{0};
-  _has_bits_[0] &= ~0x00000002u;
+  _has_bits_[0] &= ~0x00000004u;
 }
 inline int64_t ConnectionsLog_BandwidthUpgradeAttempt::_internal_duration_millis() const {
   return duration_millis_;
@@ -7145,7 +7719,7 @@ inline int64_t ConnectionsLog_BandwidthUpgradeAttempt::duration_millis() const {
   return _internal_duration_millis();
 }
 inline void ConnectionsLog_BandwidthUpgradeAttempt::_internal_set_duration_millis(int64_t value) {
-  _has_bits_[0] |= 0x00000002u;
+  _has_bits_[0] |= 0x00000004u;
   duration_millis_ = value;
 }
 inline void ConnectionsLog_BandwidthUpgradeAttempt::set_duration_millis(int64_t value) {
@@ -7155,7 +7729,7 @@ inline void ConnectionsLog_BandwidthUpgradeAttempt::set_duration_millis(int64_t
 
 // optional .location.nearby.proto.connections.Medium from_medium = 3;
 inline bool ConnectionsLog_BandwidthUpgradeAttempt::_internal_has_from_medium() const {
-  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
   return value;
 }
 inline bool ConnectionsLog_BandwidthUpgradeAttempt::has_from_medium() const {
@@ -7163,7 +7737,7 @@ inline bool ConnectionsLog_BandwidthUpgradeAttempt::has_from_medium() const {
 }
 inline void ConnectionsLog_BandwidthUpgradeAttempt::clear_from_medium() {
   from_medium_ = 0;
-  _has_bits_[0] &= ~0x00000008u;
+  _has_bits_[0] &= ~0x00000010u;
 }
 inline ::location::nearby::proto::connections::Medium ConnectionsLog_BandwidthUpgradeAttempt::_internal_from_medium() const {
   return static_cast< ::location::nearby::proto::connections::Medium >(from_medium_);
@@ -7174,7 +7748,7 @@ inline ::location::nearby::proto::connections::Medium ConnectionsLog_BandwidthUp
 }
 inline void ConnectionsLog_BandwidthUpgradeAttempt::_internal_set_from_medium(::location::nearby::proto::connections::Medium value) {
   assert(::location::nearby::proto::connections::Medium_IsValid(value));
-  _has_bits_[0] |= 0x00000008u;
+  _has_bits_[0] |= 0x00000010u;
   from_medium_ = value;
 }
 inline void ConnectionsLog_BandwidthUpgradeAttempt::set_from_medium(::location::nearby::proto::connections::Medium value) {
@@ -7184,7 +7758,7 @@ inline void ConnectionsLog_BandwidthUpgradeAttempt::set_from_medium(::location::
 
 // optional .location.nearby.proto.connections.Medium to_medium = 4;
 inline bool ConnectionsLog_BandwidthUpgradeAttempt::_internal_has_to_medium() const {
-  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
   return value;
 }
 inline bool ConnectionsLog_BandwidthUpgradeAttempt::has_to_medium() const {
@@ -7192,7 +7766,7 @@ inline bool ConnectionsLog_BandwidthUpgradeAttempt::has_to_medium() const {
 }
 inline void ConnectionsLog_BandwidthUpgradeAttempt::clear_to_medium() {
   to_medium_ = 0;
-  _has_bits_[0] &= ~0x00000010u;
+  _has_bits_[0] &= ~0x00000020u;
 }
 inline ::location::nearby::proto::connections::Medium ConnectionsLog_BandwidthUpgradeAttempt::_internal_to_medium() const {
   return static_cast< ::location::nearby::proto::connections::Medium >(to_medium_);
@@ -7203,7 +7777,7 @@ inline ::location::nearby::proto::connections::Medium ConnectionsLog_BandwidthUp
 }
 inline void ConnectionsLog_BandwidthUpgradeAttempt::_internal_set_to_medium(::location::nearby::proto::connections::Medium value) {
   assert(::location::nearby::proto::connections::Medium_IsValid(value));
-  _has_bits_[0] |= 0x00000010u;
+  _has_bits_[0] |= 0x00000020u;
   to_medium_ = value;
 }
 inline void ConnectionsLog_BandwidthUpgradeAttempt::set_to_medium(::location::nearby::proto::connections::Medium value) {
@@ -7213,7 +7787,7 @@ inline void ConnectionsLog_BandwidthUpgradeAttempt::set_to_medium(::location::ne
 
 // optional .location.nearby.proto.connections.BandwidthUpgradeResult upgrade_result = 5;
 inline bool ConnectionsLog_BandwidthUpgradeAttempt::_internal_has_upgrade_result() const {
-  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
   return value;
 }
 inline bool ConnectionsLog_BandwidthUpgradeAttempt::has_upgrade_result() const {
@@ -7221,7 +7795,7 @@ inline bool ConnectionsLog_BandwidthUpgradeAttempt::has_upgrade_result() const {
 }
 inline void ConnectionsLog_BandwidthUpgradeAttempt::clear_upgrade_result() {
   upgrade_result_ = 0;
-  _has_bits_[0] &= ~0x00000020u;
+  _has_bits_[0] &= ~0x00000040u;
 }
 inline ::location::nearby::proto::connections::BandwidthUpgradeResult ConnectionsLog_BandwidthUpgradeAttempt::_internal_upgrade_result() const {
   return static_cast< ::location::nearby::proto::connections::BandwidthUpgradeResult >(upgrade_result_);
@@ -7232,7 +7806,7 @@ inline ::location::nearby::proto::connections::BandwidthUpgradeResult Connection
 }
 inline void ConnectionsLog_BandwidthUpgradeAttempt::_internal_set_upgrade_result(::location::nearby::proto::connections::BandwidthUpgradeResult value) {
   assert(::location::nearby::proto::connections::BandwidthUpgradeResult_IsValid(value));
-  _has_bits_[0] |= 0x00000020u;
+  _has_bits_[0] |= 0x00000040u;
   upgrade_result_ = value;
 }
 inline void ConnectionsLog_BandwidthUpgradeAttempt::set_upgrade_result(::location::nearby::proto::connections::BandwidthUpgradeResult value) {
@@ -7242,7 +7816,7 @@ inline void ConnectionsLog_BandwidthUpgradeAttempt::set_upgrade_result(::locatio
 
 // optional .location.nearby.proto.connections.BandwidthUpgradeErrorStage error_stage = 6;
 inline bool ConnectionsLog_BandwidthUpgradeAttempt::_internal_has_error_stage() const {
-  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  bool value = (_has_bits_[0] & 0x00000100u) != 0;
   return value;
 }
 inline bool ConnectionsLog_BandwidthUpgradeAttempt::has_error_stage() const {
@@ -7250,7 +7824,7 @@ inline bool ConnectionsLog_BandwidthUpgradeAttempt::has_error_stage() const {
 }
 inline void ConnectionsLog_BandwidthUpgradeAttempt::clear_error_stage() {
   error_stage_ = 0;
-  _has_bits_[0] &= ~0x00000080u;
+  _has_bits_[0] &= ~0x00000100u;
 }
 inline ::location::nearby::proto::connections::BandwidthUpgradeErrorStage ConnectionsLog_BandwidthUpgradeAttempt::_internal_error_stage() const {
   return static_cast< ::location::nearby::proto::connections::BandwidthUpgradeErrorStage >(error_stage_);
@@ -7261,7 +7835,7 @@ inline ::location::nearby::proto::connections::BandwidthUpgradeErrorStage Connec
 }
 inline void ConnectionsLog_BandwidthUpgradeAttempt::_internal_set_error_stage(::location::nearby::proto::connections::BandwidthUpgradeErrorStage value) {
   assert(::location::nearby::proto::connections::BandwidthUpgradeErrorStage_IsValid(value));
-  _has_bits_[0] |= 0x00000080u;
+  _has_bits_[0] |= 0x00000100u;
   error_stage_ = value;
 }
 inline void ConnectionsLog_BandwidthUpgradeAttempt::set_error_stage(::location::nearby::proto::connections::BandwidthUpgradeErrorStage value) {
@@ -7271,7 +7845,7 @@ inline void ConnectionsLog_BandwidthUpgradeAttempt::set_error_stage(::location::
 
 // optional int64 client_flow_id = 7;
 inline bool ConnectionsLog_BandwidthUpgradeAttempt::_internal_has_client_flow_id() const {
-  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
   return value;
 }
 inline bool ConnectionsLog_BandwidthUpgradeAttempt::has_client_flow_id() const {
@@ -7279,7 +7853,7 @@ inline bool ConnectionsLog_BandwidthUpgradeAttempt::has_client_flow_id() const {
 }
 inline void ConnectionsLog_BandwidthUpgradeAttempt::clear_client_flow_id() {
   client_flow_id_ = int64_t{0};
-  _has_bits_[0] &= ~0x00000040u;
+  _has_bits_[0] &= ~0x00000080u;
 }
 inline int64_t ConnectionsLog_BandwidthUpgradeAttempt::_internal_client_flow_id() const {
   return client_flow_id_;
@@ -7289,7 +7863,7 @@ inline int64_t ConnectionsLog_BandwidthUpgradeAttempt::client_flow_id() const {
   return _internal_client_flow_id();
 }
 inline void ConnectionsLog_BandwidthUpgradeAttempt::_internal_set_client_flow_id(int64_t value) {
-  _has_bits_[0] |= 0x00000040u;
+  _has_bits_[0] |= 0x00000080u;
   client_flow_id_ = value;
 }
 inline void ConnectionsLog_BandwidthUpgradeAttempt::set_client_flow_id(int64_t value) {
@@ -7366,6 +7940,96 @@ inline void ConnectionsLog_BandwidthUpgradeAttempt::set_allocated_connection_tok
   // @@protoc_insertion_point(field_set_allocated:location.nearby.analytics.proto.ConnectionsLog.BandwidthUpgradeAttempt.connection_token)
 }
 
+// optional .location.nearby.analytics.proto.ConnectionsLog.OperationResult operation_result = 9;
+inline bool ConnectionsLog_BandwidthUpgradeAttempt::_internal_has_operation_result() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || operation_result_ != nullptr);
+  return value;
+}
+inline bool ConnectionsLog_BandwidthUpgradeAttempt::has_operation_result() const {
+  return _internal_has_operation_result();
+}
+inline void ConnectionsLog_BandwidthUpgradeAttempt::clear_operation_result() {
+  if (operation_result_ != nullptr) operation_result_->Clear();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult& ConnectionsLog_BandwidthUpgradeAttempt::_internal_operation_result() const {
+  const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* p = operation_result_;
+  return p != nullptr ? *p : reinterpret_cast<const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult&>(
+      ::location::nearby::analytics::proto::_ConnectionsLog_OperationResult_default_instance_);
+}
+inline const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult& ConnectionsLog_BandwidthUpgradeAttempt::operation_result() const {
+  // @@protoc_insertion_point(field_get:location.nearby.analytics.proto.ConnectionsLog.BandwidthUpgradeAttempt.operation_result)
+  return _internal_operation_result();
+}
+inline void ConnectionsLog_BandwidthUpgradeAttempt::unsafe_arena_set_allocated_operation_result(
+    ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* operation_result) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(operation_result_);
+  }
+  operation_result_ = operation_result;
+  if (operation_result) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.analytics.proto.ConnectionsLog.BandwidthUpgradeAttempt.operation_result)
+}
+inline ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* ConnectionsLog_BandwidthUpgradeAttempt::release_operation_result() {
+  _has_bits_[0] &= ~0x00000002u;
+  ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* temp = operation_result_;
+  operation_result_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* ConnectionsLog_BandwidthUpgradeAttempt::unsafe_arena_release_operation_result() {
+  // @@protoc_insertion_point(field_release:location.nearby.analytics.proto.ConnectionsLog.BandwidthUpgradeAttempt.operation_result)
+  _has_bits_[0] &= ~0x00000002u;
+  ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* temp = operation_result_;
+  operation_result_ = nullptr;
+  return temp;
+}
+inline ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* ConnectionsLog_BandwidthUpgradeAttempt::_internal_mutable_operation_result() {
+  _has_bits_[0] |= 0x00000002u;
+  if (operation_result_ == nullptr) {
+    auto* p = CreateMaybeMessage<::location::nearby::analytics::proto::ConnectionsLog_OperationResult>(GetArenaForAllocation());
+    operation_result_ = p;
+  }
+  return operation_result_;
+}
+inline ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* ConnectionsLog_BandwidthUpgradeAttempt::mutable_operation_result() {
+  ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* _msg = _internal_mutable_operation_result();
+  // @@protoc_insertion_point(field_mutable:location.nearby.analytics.proto.ConnectionsLog.BandwidthUpgradeAttempt.operation_result)
+  return _msg;
+}
+inline void ConnectionsLog_BandwidthUpgradeAttempt::set_allocated_operation_result(::location::nearby::analytics::proto::ConnectionsLog_OperationResult* operation_result) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete operation_result_;
+  }
+  if (operation_result) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::analytics::proto::ConnectionsLog_OperationResult>::GetOwningArena(operation_result);
+    if (message_arena != submessage_arena) {
+      operation_result = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, operation_result, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  operation_result_ = operation_result;
+  // @@protoc_insertion_point(field_set_allocated:location.nearby.analytics.proto.ConnectionsLog.BandwidthUpgradeAttempt.operation_result)
+}
+
 // -------------------------------------------------------------------
 
 // ConnectionsLog_ErrorCode
@@ -9420,6 +10084,8 @@ inline void ConnectionsLog::set_allocated_files_migration_phase(std::string* fil
 
 // -------------------------------------------------------------------
 
+// -------------------------------------------------------------------
+
 
 // @@protoc_insertion_point(namespace_scope)
 
diff --git a/compiled_proto/proto/connections_enums.pb.cc b/compiled_proto/proto/connections_enums.pb.cc
index 5796844a..18a0a748 100644
--- a/compiled_proto/proto/connections_enums.pb.cc
+++ b/compiled_proto/proto/connections_enums.pb.cc
@@ -162,6 +162,140 @@ bool ConnectionsStrategy_Parse(
   }
   return success;
 }
+bool ConnectionsClient_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+      return true;
+    default:
+      return false;
+  }
+}
+
+static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ConnectionsClient_strings[5] = {};
+
+static const char ConnectionsClient_names[] =
+  "CONNECTIONS_CLIENT_NEARBY_SHARE"
+  "CONNECTIONS_CLIENT_OTHER_FIRST_PARTY"
+  "CONNECTIONS_CLIENT_QUICK_START"
+  "CONNECTIONS_CLIENT_THIRD_PARTY"
+  "CONNECTIONS_CLIENT_UNKNOWN";
+
+static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ConnectionsClient_entries[] = {
+  { {ConnectionsClient_names + 0, 31}, 1 },
+  { {ConnectionsClient_names + 31, 36}, 3 },
+  { {ConnectionsClient_names + 67, 30}, 2 },
+  { {ConnectionsClient_names + 97, 30}, 4 },
+  { {ConnectionsClient_names + 127, 26}, 0 },
+};
+
+static const int ConnectionsClient_entries_by_number[] = {
+  4, // 0 -> CONNECTIONS_CLIENT_UNKNOWN
+  0, // 1 -> CONNECTIONS_CLIENT_NEARBY_SHARE
+  2, // 2 -> CONNECTIONS_CLIENT_QUICK_START
+  1, // 3 -> CONNECTIONS_CLIENT_OTHER_FIRST_PARTY
+  3, // 4 -> CONNECTIONS_CLIENT_THIRD_PARTY
+};
+
+const std::string& ConnectionsClient_Name(
+    ConnectionsClient value) {
+  static const bool dummy =
+      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
+          ConnectionsClient_entries,
+          ConnectionsClient_entries_by_number,
+          5, ConnectionsClient_strings);
+  (void) dummy;
+  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
+      ConnectionsClient_entries,
+      ConnectionsClient_entries_by_number,
+      5, value);
+  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
+                     ConnectionsClient_strings[idx].get();
+}
+bool ConnectionsClient_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConnectionsClient* value) {
+  int int_value;
+  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
+      ConnectionsClient_entries, 5, name, &int_value);
+  if (success) {
+    *value = static_cast<ConnectionsClient>(int_value);
+  }
+  return success;
+}
+bool ReportedEventType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+    case 6:
+      return true;
+    default:
+      return false;
+  }
+}
+
+static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ReportedEventType_strings[7] = {};
+
+static const char ReportedEventType_names[] =
+  "NC_EVENT_TYPE_ENDPOINT_FOUND"
+  "NC_EVENT_TYPE_ENDPOINT_LOST"
+  "NC_EVENT_TYPE_START_ADVERTISING"
+  "NC_EVENT_TYPE_START_DISCOVERY"
+  "NC_EVENT_TYPE_STOP_ADVERTISING"
+  "NC_EVENT_TYPE_STOP_DISCOVERY"
+  "NC_EVENT_TYPE_UNSPECIFIED";
+
+static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ReportedEventType_entries[] = {
+  { {ReportedEventType_names + 0, 28}, 3 },
+  { {ReportedEventType_names + 28, 27}, 4 },
+  { {ReportedEventType_names + 55, 31}, 5 },
+  { {ReportedEventType_names + 86, 29}, 1 },
+  { {ReportedEventType_names + 115, 30}, 6 },
+  { {ReportedEventType_names + 145, 28}, 2 },
+  { {ReportedEventType_names + 173, 25}, 0 },
+};
+
+static const int ReportedEventType_entries_by_number[] = {
+  6, // 0 -> NC_EVENT_TYPE_UNSPECIFIED
+  3, // 1 -> NC_EVENT_TYPE_START_DISCOVERY
+  5, // 2 -> NC_EVENT_TYPE_STOP_DISCOVERY
+  0, // 3 -> NC_EVENT_TYPE_ENDPOINT_FOUND
+  1, // 4 -> NC_EVENT_TYPE_ENDPOINT_LOST
+  2, // 5 -> NC_EVENT_TYPE_START_ADVERTISING
+  4, // 6 -> NC_EVENT_TYPE_STOP_ADVERTISING
+};
+
+const std::string& ReportedEventType_Name(
+    ReportedEventType value) {
+  static const bool dummy =
+      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
+          ReportedEventType_entries,
+          ReportedEventType_entries_by_number,
+          7, ReportedEventType_strings);
+  (void) dummy;
+  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
+      ReportedEventType_entries,
+      ReportedEventType_entries_by_number,
+      7, value);
+  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
+                     ReportedEventType_strings[idx].get();
+}
+bool ReportedEventType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ReportedEventType* value) {
+  int int_value;
+  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
+      ReportedEventType_entries, 7, name, &int_value);
+  if (success) {
+    *value = static_cast<ReportedEventType>(int_value);
+  }
+  return success;
+}
 bool SessionRole_IsValid(int value) {
   switch (value) {
     case 0:
@@ -1611,6 +1745,7 @@ bool OperationResultCode_IsValid(int value) {
     case 2510:
     case 2511:
     case 2512:
+    case 2513:
     case 3000:
     case 3001:
     case 3002:
@@ -1757,7 +1892,7 @@ bool OperationResultCode_IsValid(int value) {
   }
 }
 
-static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> OperationResultCode_strings[240] = {};
+static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> OperationResultCode_strings[241] = {};
 
 static const char OperationResultCode_names[] =
   "CLIENT_CANCELLATION_BT_SERVER_SOCKET_CREATION"
@@ -1926,6 +2061,7 @@ static const char OperationResultCode_names[] =
   "MISCELLEANEOUS_BT_SYSTEM_SERVICE_NULL"
   "MISCELLEANEOUS_L2CAP_SYSTEM_SERVICE_NULL"
   "MISCELLEANEOUS_MOVE_TO_NEW_MEDIUM"
+  "MISCELLEANEOUS_WEB_RTC_FAILED_TO_RECEIVE_MESSAGE"
   "MISCELLEANEOUS_WEB_RTC_GET_DROIDGUARD_RESULT_FAILURE"
   "MISCELLEANEOUS_WEB_RTC_TACHYON_SIGNALING_MESSENGER_NULL"
   "MISCELLEANEOUS_WIFI_AWARE_SYSTEM_SERVICE_NULL"
@@ -2168,80 +2304,81 @@ static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry OperationResultCode_en
   { {OperationResultCode_names + 7530, 37}, 2505 },
   { {OperationResultCode_names + 7567, 40}, 2504 },
   { {OperationResultCode_names + 7607, 33}, 2501 },
-  { {OperationResultCode_names + 7640, 52}, 2511 },
-  { {OperationResultCode_names + 7692, 55}, 2512 },
-  { {OperationResultCode_names + 7747, 45}, 2506 },
-  { {OperationResultCode_names + 7792, 46}, 2507 },
-  { {OperationResultCode_names + 7838, 56}, 2502 },
-  { {OperationResultCode_names + 7894, 47}, 2509 },
-  { {OperationResultCode_names + 7941, 43}, 2508 },
-  { {OperationResultCode_names + 7984, 45}, 4500 },
-  { {OperationResultCode_names + 8029, 44}, 4504 },
-  { {OperationResultCode_names + 8073, 49}, 4515 },
-  { {OperationResultCode_names + 8122, 29}, 4518 },
-  { {OperationResultCode_names + 8151, 38}, 4536 },
-  { {OperationResultCode_names + 8189, 48}, 4501 },
-  { {OperationResultCode_names + 8237, 43}, 4506 },
-  { {OperationResultCode_names + 8280, 35}, 4530 },
-  { {OperationResultCode_names + 8315, 23}, 4520 },
-  { {OperationResultCode_names + 8338, 37}, 4538 },
-  { {OperationResultCode_names + 8375, 41}, 4563 },
-  { {OperationResultCode_names + 8416, 32}, 4503 },
-  { {OperationResultCode_names + 8448, 35}, 4514 },
-  { {OperationResultCode_names + 8483, 45}, 4552 },
-  { {OperationResultCode_names + 8528, 40}, 4532 },
-  { {OperationResultCode_names + 8568, 40}, 4535 },
-  { {OperationResultCode_names + 8608, 48}, 4547 },
-  { {OperationResultCode_names + 8656, 60}, 4556 },
-  { {OperationResultCode_names + 8716, 56}, 4558 },
-  { {OperationResultCode_names + 8772, 60}, 4557 },
-  { {OperationResultCode_names + 8832, 56}, 4553 },
-  { {OperationResultCode_names + 8888, 52}, 4555 },
-  { {OperationResultCode_names + 8940, 56}, 4554 },
-  { {OperationResultCode_names + 8996, 43}, 4559 },
-  { {OperationResultCode_names + 9039, 43}, 4560 },
-  { {OperationResultCode_names + 9082, 37}, 4561 },
-  { {OperationResultCode_names + 9119, 41}, 4562 },
-  { {OperationResultCode_names + 9160, 46}, 4505 },
-  { {OperationResultCode_names + 9206, 26}, 4519 },
-  { {OperationResultCode_names + 9232, 40}, 4537 },
-  { {OperationResultCode_names + 9272, 29}, 4566 },
-  { {OperationResultCode_names + 9301, 44}, 4507 },
-  { {OperationResultCode_names + 9345, 36}, 4531 },
-  { {OperationResultCode_names + 9381, 24}, 4525 },
-  { {OperationResultCode_names + 9405, 38}, 4539 },
-  { {OperationResultCode_names + 9443, 42}, 4564 },
-  { {OperationResultCode_names + 9485, 44}, 4508 },
-  { {OperationResultCode_names + 9529, 24}, 4522 },
-  { {OperationResultCode_names + 9553, 44}, 4513 },
-  { {OperationResultCode_names + 9597, 24}, 4521 },
-  { {OperationResultCode_names + 9621, 35}, 4502 },
-  { {OperationResultCode_names + 9656, 48}, 4512 },
-  { {OperationResultCode_names + 9704, 28}, 4524 },
-  { {OperationResultCode_names + 9732, 42}, 4540 },
-  { {OperationResultCode_names + 9774, 51}, 4509 },
-  { {OperationResultCode_names + 9825, 31}, 4523 },
-  { {OperationResultCode_names + 9856, 45}, 4541 },
-  { {OperationResultCode_names + 9901, 52}, 4511 },
-  { {OperationResultCode_names + 9953, 39}, 4516 },
-  { {OperationResultCode_names + 9992, 41}, 4533 },
-  { {OperationResultCode_names + 10033, 32}, 4527 },
-  { {OperationResultCode_names + 10065, 32}, 4529 },
-  { {OperationResultCode_names + 10097, 28}, 4528 },
-  { {OperationResultCode_names + 10125, 46}, 4546 },
-  { {OperationResultCode_names + 10171, 48}, 4549 },
-  { {OperationResultCode_names + 10219, 48}, 4551 },
-  { {OperationResultCode_names + 10267, 54}, 4545 },
-  { {OperationResultCode_names + 10321, 54}, 4542 },
-  { {OperationResultCode_names + 10375, 53}, 4510 },
-  { {OperationResultCode_names + 10428, 40}, 4517 },
-  { {OperationResultCode_names + 10468, 52}, 4544 },
-  { {OperationResultCode_names + 10520, 44}, 4534 },
-  { {OperationResultCode_names + 10564, 33}, 4526 },
-  { {OperationResultCode_names + 10597, 49}, 4548 },
-  { {OperationResultCode_names + 10646, 49}, 4550 },
-  { {OperationResultCode_names + 10695, 55}, 4543 },
-  { {OperationResultCode_names + 10750, 32}, 4565 },
+  { {OperationResultCode_names + 7640, 48}, 2513 },
+  { {OperationResultCode_names + 7688, 52}, 2511 },
+  { {OperationResultCode_names + 7740, 55}, 2512 },
+  { {OperationResultCode_names + 7795, 45}, 2506 },
+  { {OperationResultCode_names + 7840, 46}, 2507 },
+  { {OperationResultCode_names + 7886, 56}, 2502 },
+  { {OperationResultCode_names + 7942, 47}, 2509 },
+  { {OperationResultCode_names + 7989, 43}, 2508 },
+  { {OperationResultCode_names + 8032, 45}, 4500 },
+  { {OperationResultCode_names + 8077, 44}, 4504 },
+  { {OperationResultCode_names + 8121, 49}, 4515 },
+  { {OperationResultCode_names + 8170, 29}, 4518 },
+  { {OperationResultCode_names + 8199, 38}, 4536 },
+  { {OperationResultCode_names + 8237, 48}, 4501 },
+  { {OperationResultCode_names + 8285, 43}, 4506 },
+  { {OperationResultCode_names + 8328, 35}, 4530 },
+  { {OperationResultCode_names + 8363, 23}, 4520 },
+  { {OperationResultCode_names + 8386, 37}, 4538 },
+  { {OperationResultCode_names + 8423, 41}, 4563 },
+  { {OperationResultCode_names + 8464, 32}, 4503 },
+  { {OperationResultCode_names + 8496, 35}, 4514 },
+  { {OperationResultCode_names + 8531, 45}, 4552 },
+  { {OperationResultCode_names + 8576, 40}, 4532 },
+  { {OperationResultCode_names + 8616, 40}, 4535 },
+  { {OperationResultCode_names + 8656, 48}, 4547 },
+  { {OperationResultCode_names + 8704, 60}, 4556 },
+  { {OperationResultCode_names + 8764, 56}, 4558 },
+  { {OperationResultCode_names + 8820, 60}, 4557 },
+  { {OperationResultCode_names + 8880, 56}, 4553 },
+  { {OperationResultCode_names + 8936, 52}, 4555 },
+  { {OperationResultCode_names + 8988, 56}, 4554 },
+  { {OperationResultCode_names + 9044, 43}, 4559 },
+  { {OperationResultCode_names + 9087, 43}, 4560 },
+  { {OperationResultCode_names + 9130, 37}, 4561 },
+  { {OperationResultCode_names + 9167, 41}, 4562 },
+  { {OperationResultCode_names + 9208, 46}, 4505 },
+  { {OperationResultCode_names + 9254, 26}, 4519 },
+  { {OperationResultCode_names + 9280, 40}, 4537 },
+  { {OperationResultCode_names + 9320, 29}, 4566 },
+  { {OperationResultCode_names + 9349, 44}, 4507 },
+  { {OperationResultCode_names + 9393, 36}, 4531 },
+  { {OperationResultCode_names + 9429, 24}, 4525 },
+  { {OperationResultCode_names + 9453, 38}, 4539 },
+  { {OperationResultCode_names + 9491, 42}, 4564 },
+  { {OperationResultCode_names + 9533, 44}, 4508 },
+  { {OperationResultCode_names + 9577, 24}, 4522 },
+  { {OperationResultCode_names + 9601, 44}, 4513 },
+  { {OperationResultCode_names + 9645, 24}, 4521 },
+  { {OperationResultCode_names + 9669, 35}, 4502 },
+  { {OperationResultCode_names + 9704, 48}, 4512 },
+  { {OperationResultCode_names + 9752, 28}, 4524 },
+  { {OperationResultCode_names + 9780, 42}, 4540 },
+  { {OperationResultCode_names + 9822, 51}, 4509 },
+  { {OperationResultCode_names + 9873, 31}, 4523 },
+  { {OperationResultCode_names + 9904, 45}, 4541 },
+  { {OperationResultCode_names + 9949, 52}, 4511 },
+  { {OperationResultCode_names + 10001, 39}, 4516 },
+  { {OperationResultCode_names + 10040, 41}, 4533 },
+  { {OperationResultCode_names + 10081, 32}, 4527 },
+  { {OperationResultCode_names + 10113, 32}, 4529 },
+  { {OperationResultCode_names + 10145, 28}, 4528 },
+  { {OperationResultCode_names + 10173, 46}, 4546 },
+  { {OperationResultCode_names + 10219, 48}, 4549 },
+  { {OperationResultCode_names + 10267, 48}, 4551 },
+  { {OperationResultCode_names + 10315, 54}, 4545 },
+  { {OperationResultCode_names + 10369, 54}, 4542 },
+  { {OperationResultCode_names + 10423, 53}, 4510 },
+  { {OperationResultCode_names + 10476, 40}, 4517 },
+  { {OperationResultCode_names + 10516, 52}, 4544 },
+  { {OperationResultCode_names + 10568, 44}, 4534 },
+  { {OperationResultCode_names + 10612, 33}, 4526 },
+  { {OperationResultCode_names + 10645, 49}, 4548 },
+  { {OperationResultCode_names + 10694, 49}, 4550 },
+  { {OperationResultCode_names + 10743, 55}, 4543 },
+  { {OperationResultCode_names + 10798, 32}, 4565 },
 };
 
 static const int OperationResultCode_entries_by_number[] = {
@@ -2334,17 +2471,18 @@ static const int OperationResultCode_entries_by_number[] = {
   38, // 2016 -> CLIENT_UNSUPPORTED_USB_TO_BE_UPGRADE_MEDIUM
   161, // 2500 -> MISCELLEANEOUS_BLUETOOTH_MAC_ADDRESS_NULL
   165, // 2501 -> MISCELLEANEOUS_MOVE_TO_NEW_MEDIUM
-  170, // 2502 -> MISCELLEANEOUS_WIFI_HOTSPOT_SOFT_AP_BLOCKED_BY_PROVISION
+  171, // 2502 -> MISCELLEANEOUS_WIFI_HOTSPOT_SOFT_AP_BLOCKED_BY_PROVISION
   160, // 2503 -> MISCELLEANEOUS_BLE_SYSTEM_SERVICE_NULL
   164, // 2504 -> MISCELLEANEOUS_L2CAP_SYSTEM_SERVICE_NULL
   163, // 2505 -> MISCELLEANEOUS_BT_SYSTEM_SERVICE_NULL
-  168, // 2506 -> MISCELLEANEOUS_WIFI_AWARE_SYSTEM_SERVICE_NULL
-  169, // 2507 -> MISCELLEANEOUS_WIFI_DIRECT_SYSTEM_SERVICE_NULL
-  172, // 2508 -> MISCELLEANEOUS_WIFI_LAN_SYSTEM_SERVICE_NULL
-  171, // 2509 -> MISCELLEANEOUS_WIFI_HOTSPOT_SYSTEM_SERVICE_NULL
+  169, // 2506 -> MISCELLEANEOUS_WIFI_AWARE_SYSTEM_SERVICE_NULL
+  170, // 2507 -> MISCELLEANEOUS_WIFI_DIRECT_SYSTEM_SERVICE_NULL
+  173, // 2508 -> MISCELLEANEOUS_WIFI_LAN_SYSTEM_SERVICE_NULL
+  172, // 2509 -> MISCELLEANEOUS_WIFI_HOTSPOT_SYSTEM_SERVICE_NULL
   162, // 2510 -> MISCELLEANEOUS_BT_NOT_ACCEPTING_CONNECTION_FOR_WORK_PROFILE
-  166, // 2511 -> MISCELLEANEOUS_WEB_RTC_GET_DROIDGUARD_RESULT_FAILURE
-  167, // 2512 -> MISCELLEANEOUS_WEB_RTC_TACHYON_SIGNALING_MESSENGER_NULL
+  167, // 2511 -> MISCELLEANEOUS_WEB_RTC_GET_DROIDGUARD_RESULT_FAILURE
+  168, // 2512 -> MISCELLEANEOUS_WEB_RTC_TACHYON_SIGNALING_MESSENGER_NULL
+  166, // 2513 -> MISCELLEANEOUS_WEB_RTC_FAILED_TO_RECEIVE_MESSAGE
   116, // 3000 -> IO_FILE_OPENING_ERROR
   117, // 3001 -> IO_FILE_READING_ERROR
   118, // 3002 -> IO_FILE_WRITING_ERROR
@@ -2418,73 +2556,73 @@ static const int OperationResultCode_entries_by_number[] = {
   48, // 3555 -> CONNECTIVITY_BT_SERVER_SOCKET_CREATION_SECURITY_EXCEPTION_FAILURE
   55, // 3556 -> CONNECTIVITY_L2CAP_CLIENT_SOCKET_CREATION_TIMEOUT_FAILURE
   70, // 3557 -> CONNECTIVITY_WEB_RTC_UNSATISFIED_LINK_ERROR
-  173, // 4500 -> NEARBY_BLE_ADVERTISEMENT_MAPPING_TO_MAC_ERROR
-  178, // 4501 -> NEARBY_BLUETOOTH_MAC_ADDRESS_INVALID_FOR_CONNECT
-  213, // 4502 -> NEARBY_WEB_RTC_CONNECTION_FLOW_NULL
-  184, // 4503 -> NEARBY_GENERIC_CONNECTION_CLOSED
-  174, // 4504 -> NEARBY_BLE_ENDPOINT_CHANNEL_CREATION_FAILURE
-  200, // 4505 -> NEARBY_L2CAP_ENDPOINT_CHANNEL_CREATION_FAILURE
-  179, // 4506 -> NEARBY_BT_ENDPOINT_CHANNEL_CREATION_FAILURE
-  204, // 4507 -> NEARBY_LAN_ENDPOINT_CHANNEL_CREATION_FAILURE
-  209, // 4508 -> NEARBY_NFC_ENDPOINT_CHANNEL_CREATION_FAILURE
-  217, // 4509 -> NEARBY_WIFI_AWARE_ENDPOINT_CHANNEL_CREATION_FAILURE
-  231, // 4510 -> NEARBY_WIFI_HOTSPOT_ENDPOINT_CHANNEL_CREATION_FAILURE
-  220, // 4511 -> NEARBY_WIFI_DIRECT_ENDPOINT_CHANNEL_CREATION_FAILURE
-  214, // 4512 -> NEARBY_WEB_RTC_ENDPOINT_CHANNEL_CREATION_FAILURE
-  211, // 4513 -> NEARBY_USB_ENDPOINT_CHANNEL_CREATION_FAILURE
-  185, // 4514 -> NEARBY_GENERIC_ENDPOINT_UNENCRYPTED
-  175, // 4515 -> NEARBY_BLE_GATT_ADVERTISEMENT_NULL_FOR_CONNECTION
-  221, // 4516 -> NEARBY_WIFI_DIRECT_HOST_ON_SRD_CHANNELS
-  232, // 4517 -> NEARBY_WIFI_HOTSPOT_HOST_ON_SRD_CHANNELS
-  176, // 4518 -> NEARBY_BLE_GATT_NULL_CALLBACK
-  201, // 4519 -> NEARBY_L2CAP_NULL_CALLBACK
-  181, // 4520 -> NEARBY_BT_NULL_CALLBACK
-  212, // 4521 -> NEARBY_USB_NULL_CALLBACK
-  210, // 4522 -> NEARBY_NFC_NULL_CALLBACK
-  218, // 4523 -> NEARBY_WIFI_AWARE_NULL_CALLBACK
-  215, // 4524 -> NEARBY_WEB_RTC_NULL_CALLBACK
-  206, // 4525 -> NEARBY_LAN_NULL_CALLBACK
-  235, // 4526 -> NEARBY_WIFI_HOTSPOT_NULL_CALLBACK
-  223, // 4527 -> NEARBY_WIFI_DIRECT_NULL_CALLBACK
-  225, // 4528 -> NEARBY_WIFI_DIRECT_NULL_SSID
-  224, // 4529 -> NEARBY_WIFI_DIRECT_NULL_PASSWORD
-  180, // 4530 -> NEARBY_BT_MULTIPLEX_SOCKET_DISABLED
-  205, // 4531 -> NEARBY_LAN_MULTIPLEX_SOCKET_DISABLED
-  187, // 4532 -> NEARBY_GENERIC_NEW_ENDPOINT_CHANNEL_NULL
-  222, // 4533 -> NEARBY_WIFI_DIRECT_NO_GROUP_FOR_LISTENING
-  234, // 4534 -> NEARBY_WIFI_HOTSPOT_NO_HOTSPOT_FOR_LISTENING
-  188, // 4535 -> NEARBY_GENERIC_OLD_ENDPOINT_CHANNEL_NULL
-  177, // 4536 -> NEARBY_BLE_OPERATION_REGISTERED_FAILED
-  202, // 4537 -> NEARBY_L2CAP_OPERATION_REGISTERED_FAILED
-  182, // 4538 -> NEARBY_BT_OPERATION_REGISTERED_FAILED
-  207, // 4539 -> NEARBY_LAN_OPERATION_REGISTERED_FAILED
-  216, // 4540 -> NEARBY_WEB_RTC_OPERATION_REGISTERED_FAILED
-  219, // 4541 -> NEARBY_WIFI_AWARE_OPERATION_REGISTERED_FAILED
-  230, // 4542 -> NEARBY_WIFI_HOTSPOT_DIRECT_OPERATION_REGISTERED_FAILED
-  238, // 4543 -> NEARBY_WIFI_HOTSPOT_SOFT_AP_OPERATION_REGISTERED_FAILED
-  233, // 4544 -> NEARBY_WIFI_HOTSPOT_LOHS_OPERATION_REGISTERED_FAILED
-  229, // 4545 -> NEARBY_WIFI_HOTSPOT_CLIENT_OPERATION_REGISTERED_FAILED
-  226, // 4546 -> NEARBY_WIFI_DIRECT_OPERATION_REGISTERED_FAILED
-  189, // 4547 -> NEARBY_GENERIC_OUTGOING_PAYLOAD_CREATION_FAILURE
-  236, // 4548 -> NEARBY_WIFI_HOTSPOT_P2P_NON_DBS_WANT_2G_BUT_AP_5G
-  227, // 4549 -> NEARBY_WIFI_DIRECT_P2P_NON_DBS_WANT_2G_BUT_AP_5G
-  237, // 4550 -> NEARBY_WIFI_HOTSPOT_P2P_NON_DBS_WANT_5G_BUT_AP_2G
-  228, // 4551 -> NEARBY_WIFI_DIRECT_P2P_NON_DBS_WANT_5G_BUT_AP_2G
-  186, // 4552 -> NEARBY_GENERIC_INCOMING_PAYLOAD_NOT_DATA_TYPE
-  193, // 4553 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_EVENT_TYPE_ERROR
-  195, // 4554 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_FRAME_TYPE_ERROR
-  194, // 4555 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_FORMAT_ERROR
-  190, // 4556 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_ACK_EVENT_TYPE_ERROR
-  192, // 4557 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_ACK_FRAME_TYPE_ERROR
-  191, // 4558 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_ACK_FORMAT_ERROR
-  196, // 4559 -> NEARBY_GENERIC_REMOTE_ENDPOINT_STATUS_ERROR
-  197, // 4560 -> NEARBY_GENERIC_REMOTE_REPORT_PAYLOADS_ERROR
-  198, // 4561 -> NEARBY_GENERIC_REMOTE_UPGRADE_FAILURE
-  199, // 4562 -> NEARBY_GENERIC_SEND_PAYLOAD_EXECUTOR_NULL
-  183, // 4563 -> NEARBY_BT_VIRTUAL_SOCKET_CREATION_FAILURE
-  208, // 4564 -> NEARBY_LAN_VIRTUAL_SOCKET_CREATION_FAILURE
-  239, // 4565 -> NEARBY_WIFI_LAN_IP_ADDRESS_ERROR
-  203, // 4566 -> NEARBY_L2CAP_PSM_NOT_POSITIVE
+  174, // 4500 -> NEARBY_BLE_ADVERTISEMENT_MAPPING_TO_MAC_ERROR
+  179, // 4501 -> NEARBY_BLUETOOTH_MAC_ADDRESS_INVALID_FOR_CONNECT
+  214, // 4502 -> NEARBY_WEB_RTC_CONNECTION_FLOW_NULL
+  185, // 4503 -> NEARBY_GENERIC_CONNECTION_CLOSED
+  175, // 4504 -> NEARBY_BLE_ENDPOINT_CHANNEL_CREATION_FAILURE
+  201, // 4505 -> NEARBY_L2CAP_ENDPOINT_CHANNEL_CREATION_FAILURE
+  180, // 4506 -> NEARBY_BT_ENDPOINT_CHANNEL_CREATION_FAILURE
+  205, // 4507 -> NEARBY_LAN_ENDPOINT_CHANNEL_CREATION_FAILURE
+  210, // 4508 -> NEARBY_NFC_ENDPOINT_CHANNEL_CREATION_FAILURE
+  218, // 4509 -> NEARBY_WIFI_AWARE_ENDPOINT_CHANNEL_CREATION_FAILURE
+  232, // 4510 -> NEARBY_WIFI_HOTSPOT_ENDPOINT_CHANNEL_CREATION_FAILURE
+  221, // 4511 -> NEARBY_WIFI_DIRECT_ENDPOINT_CHANNEL_CREATION_FAILURE
+  215, // 4512 -> NEARBY_WEB_RTC_ENDPOINT_CHANNEL_CREATION_FAILURE
+  212, // 4513 -> NEARBY_USB_ENDPOINT_CHANNEL_CREATION_FAILURE
+  186, // 4514 -> NEARBY_GENERIC_ENDPOINT_UNENCRYPTED
+  176, // 4515 -> NEARBY_BLE_GATT_ADVERTISEMENT_NULL_FOR_CONNECTION
+  222, // 4516 -> NEARBY_WIFI_DIRECT_HOST_ON_SRD_CHANNELS
+  233, // 4517 -> NEARBY_WIFI_HOTSPOT_HOST_ON_SRD_CHANNELS
+  177, // 4518 -> NEARBY_BLE_GATT_NULL_CALLBACK
+  202, // 4519 -> NEARBY_L2CAP_NULL_CALLBACK
+  182, // 4520 -> NEARBY_BT_NULL_CALLBACK
+  213, // 4521 -> NEARBY_USB_NULL_CALLBACK
+  211, // 4522 -> NEARBY_NFC_NULL_CALLBACK
+  219, // 4523 -> NEARBY_WIFI_AWARE_NULL_CALLBACK
+  216, // 4524 -> NEARBY_WEB_RTC_NULL_CALLBACK
+  207, // 4525 -> NEARBY_LAN_NULL_CALLBACK
+  236, // 4526 -> NEARBY_WIFI_HOTSPOT_NULL_CALLBACK
+  224, // 4527 -> NEARBY_WIFI_DIRECT_NULL_CALLBACK
+  226, // 4528 -> NEARBY_WIFI_DIRECT_NULL_SSID
+  225, // 4529 -> NEARBY_WIFI_DIRECT_NULL_PASSWORD
+  181, // 4530 -> NEARBY_BT_MULTIPLEX_SOCKET_DISABLED
+  206, // 4531 -> NEARBY_LAN_MULTIPLEX_SOCKET_DISABLED
+  188, // 4532 -> NEARBY_GENERIC_NEW_ENDPOINT_CHANNEL_NULL
+  223, // 4533 -> NEARBY_WIFI_DIRECT_NO_GROUP_FOR_LISTENING
+  235, // 4534 -> NEARBY_WIFI_HOTSPOT_NO_HOTSPOT_FOR_LISTENING
+  189, // 4535 -> NEARBY_GENERIC_OLD_ENDPOINT_CHANNEL_NULL
+  178, // 4536 -> NEARBY_BLE_OPERATION_REGISTERED_FAILED
+  203, // 4537 -> NEARBY_L2CAP_OPERATION_REGISTERED_FAILED
+  183, // 4538 -> NEARBY_BT_OPERATION_REGISTERED_FAILED
+  208, // 4539 -> NEARBY_LAN_OPERATION_REGISTERED_FAILED
+  217, // 4540 -> NEARBY_WEB_RTC_OPERATION_REGISTERED_FAILED
+  220, // 4541 -> NEARBY_WIFI_AWARE_OPERATION_REGISTERED_FAILED
+  231, // 4542 -> NEARBY_WIFI_HOTSPOT_DIRECT_OPERATION_REGISTERED_FAILED
+  239, // 4543 -> NEARBY_WIFI_HOTSPOT_SOFT_AP_OPERATION_REGISTERED_FAILED
+  234, // 4544 -> NEARBY_WIFI_HOTSPOT_LOHS_OPERATION_REGISTERED_FAILED
+  230, // 4545 -> NEARBY_WIFI_HOTSPOT_CLIENT_OPERATION_REGISTERED_FAILED
+  227, // 4546 -> NEARBY_WIFI_DIRECT_OPERATION_REGISTERED_FAILED
+  190, // 4547 -> NEARBY_GENERIC_OUTGOING_PAYLOAD_CREATION_FAILURE
+  237, // 4548 -> NEARBY_WIFI_HOTSPOT_P2P_NON_DBS_WANT_2G_BUT_AP_5G
+  228, // 4549 -> NEARBY_WIFI_DIRECT_P2P_NON_DBS_WANT_2G_BUT_AP_5G
+  238, // 4550 -> NEARBY_WIFI_HOTSPOT_P2P_NON_DBS_WANT_5G_BUT_AP_2G
+  229, // 4551 -> NEARBY_WIFI_DIRECT_P2P_NON_DBS_WANT_5G_BUT_AP_2G
+  187, // 4552 -> NEARBY_GENERIC_INCOMING_PAYLOAD_NOT_DATA_TYPE
+  194, // 4553 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_EVENT_TYPE_ERROR
+  196, // 4554 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_FRAME_TYPE_ERROR
+  195, // 4555 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_FORMAT_ERROR
+  191, // 4556 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_ACK_EVENT_TYPE_ERROR
+  193, // 4557 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_ACK_FRAME_TYPE_ERROR
+  192, // 4558 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_ACK_FORMAT_ERROR
+  197, // 4559 -> NEARBY_GENERIC_REMOTE_ENDPOINT_STATUS_ERROR
+  198, // 4560 -> NEARBY_GENERIC_REMOTE_REPORT_PAYLOADS_ERROR
+  199, // 4561 -> NEARBY_GENERIC_REMOTE_UPGRADE_FAILURE
+  200, // 4562 -> NEARBY_GENERIC_SEND_PAYLOAD_EXECUTOR_NULL
+  184, // 4563 -> NEARBY_BT_VIRTUAL_SOCKET_CREATION_FAILURE
+  209, // 4564 -> NEARBY_LAN_VIRTUAL_SOCKET_CREATION_FAILURE
+  240, // 4565 -> NEARBY_WIFI_LAN_IP_ADDRESS_ERROR
+  204, // 4566 -> NEARBY_L2CAP_PSM_NOT_POSITIVE
 };
 
 const std::string& OperationResultCode_Name(
@@ -2493,12 +2631,12 @@ const std::string& OperationResultCode_Name(
       ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
           OperationResultCode_entries,
           OperationResultCode_entries_by_number,
-          240, OperationResultCode_strings);
+          241, OperationResultCode_strings);
   (void) dummy;
   int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
       OperationResultCode_entries,
       OperationResultCode_entries_by_number,
-      240, value);
+      241, value);
   return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                      OperationResultCode_strings[idx].get();
 }
@@ -2506,7 +2644,7 @@ bool OperationResultCode_Parse(
     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OperationResultCode* value) {
   int int_value;
   bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
-      OperationResultCode_entries, 240, name, &int_value);
+      OperationResultCode_entries, 241, name, &int_value);
   if (success) {
     *value = static_cast<OperationResultCode>(int_value);
   }
diff --git a/compiled_proto/proto/connections_enums.pb.h b/compiled_proto/proto/connections_enums.pb.h
index 8a173350..3fa2fb17 100644
--- a/compiled_proto/proto/connections_enums.pb.h
+++ b/compiled_proto/proto/connections_enums.pb.h
@@ -104,6 +104,52 @@ inline const std::string& ConnectionsStrategy_Name(T enum_t_value) {
 }
 bool ConnectionsStrategy_Parse(
     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConnectionsStrategy* value);
+enum ConnectionsClient : int {
+  CONNECTIONS_CLIENT_UNKNOWN = 0,
+  CONNECTIONS_CLIENT_NEARBY_SHARE = 1,
+  CONNECTIONS_CLIENT_QUICK_START = 2,
+  CONNECTIONS_CLIENT_OTHER_FIRST_PARTY = 3,
+  CONNECTIONS_CLIENT_THIRD_PARTY = 4
+};
+bool ConnectionsClient_IsValid(int value);
+constexpr ConnectionsClient ConnectionsClient_MIN = CONNECTIONS_CLIENT_UNKNOWN;
+constexpr ConnectionsClient ConnectionsClient_MAX = CONNECTIONS_CLIENT_THIRD_PARTY;
+constexpr int ConnectionsClient_ARRAYSIZE = ConnectionsClient_MAX + 1;
+
+const std::string& ConnectionsClient_Name(ConnectionsClient value);
+template<typename T>
+inline const std::string& ConnectionsClient_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ConnectionsClient>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ConnectionsClient_Name.");
+  return ConnectionsClient_Name(static_cast<ConnectionsClient>(enum_t_value));
+}
+bool ConnectionsClient_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConnectionsClient* value);
+enum ReportedEventType : int {
+  NC_EVENT_TYPE_UNSPECIFIED = 0,
+  NC_EVENT_TYPE_START_DISCOVERY = 1,
+  NC_EVENT_TYPE_STOP_DISCOVERY = 2,
+  NC_EVENT_TYPE_ENDPOINT_FOUND = 3,
+  NC_EVENT_TYPE_ENDPOINT_LOST = 4,
+  NC_EVENT_TYPE_START_ADVERTISING = 5,
+  NC_EVENT_TYPE_STOP_ADVERTISING = 6
+};
+bool ReportedEventType_IsValid(int value);
+constexpr ReportedEventType ReportedEventType_MIN = NC_EVENT_TYPE_UNSPECIFIED;
+constexpr ReportedEventType ReportedEventType_MAX = NC_EVENT_TYPE_STOP_ADVERTISING;
+constexpr int ReportedEventType_ARRAYSIZE = ReportedEventType_MAX + 1;
+
+const std::string& ReportedEventType_Name(ReportedEventType value);
+template<typename T>
+inline const std::string& ReportedEventType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ReportedEventType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ReportedEventType_Name.");
+  return ReportedEventType_Name(static_cast<ReportedEventType>(enum_t_value));
+}
+bool ReportedEventType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ReportedEventType* value);
 enum SessionRole : int {
   UNKNOWN_SESSION_ROLE = 0,
   ADVERTISER = 1,
@@ -648,6 +694,7 @@ enum OperationResultCode : int {
   MISCELLEANEOUS_BT_NOT_ACCEPTING_CONNECTION_FOR_WORK_PROFILE = 2510,
   MISCELLEANEOUS_WEB_RTC_GET_DROIDGUARD_RESULT_FAILURE = 2511,
   MISCELLEANEOUS_WEB_RTC_TACHYON_SIGNALING_MESSENGER_NULL = 2512,
+  MISCELLEANEOUS_WEB_RTC_FAILED_TO_RECEIVE_MESSAGE = 2513,
   IO_FILE_OPENING_ERROR = 3000,
   IO_FILE_READING_ERROR = 3001,
   IO_FILE_WRITING_ERROR = 3002,
@@ -831,6 +878,8 @@ PROTOBUF_NAMESPACE_OPEN
 
 template <> struct is_proto_enum< ::location::nearby::proto::connections::EventType> : ::std::true_type {};
 template <> struct is_proto_enum< ::location::nearby::proto::connections::ConnectionsStrategy> : ::std::true_type {};
+template <> struct is_proto_enum< ::location::nearby::proto::connections::ConnectionsClient> : ::std::true_type {};
+template <> struct is_proto_enum< ::location::nearby::proto::connections::ReportedEventType> : ::std::true_type {};
 template <> struct is_proto_enum< ::location::nearby::proto::connections::SessionRole> : ::std::true_type {};
 template <> struct is_proto_enum< ::location::nearby::proto::connections::Medium> : ::std::true_type {};
 template <> struct is_proto_enum< ::location::nearby::proto::connections::ConnectionTechnology> : ::std::true_type {};
diff --git a/compiled_proto/proto/mediums/multiplex_frames.pb.cc b/compiled_proto/proto/mediums/multiplex_frames.pb.cc
new file mode 100644
index 00000000..aa39ff0b
--- /dev/null
+++ b/compiled_proto/proto/mediums/multiplex_frames.pb.cc
@@ -0,0 +1,2092 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: proto/mediums/multiplex_frames.proto
+
+#include "proto/mediums/multiplex_frames.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/wire_format_lite.h>
+#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+
+PROTOBUF_PRAGMA_INIT_SEG
+namespace location {
+namespace nearby {
+namespace mediums {
+constexpr MultiplexFrame::MultiplexFrame(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : header_(nullptr)
+  , frame_type_(0)
+
+  , _oneof_case_{}{}
+struct MultiplexFrameDefaultTypeInternal {
+  constexpr MultiplexFrameDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~MultiplexFrameDefaultTypeInternal() {}
+  union {
+    MultiplexFrame _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MultiplexFrameDefaultTypeInternal _MultiplexFrame_default_instance_;
+constexpr MultiplexFrameHeader::MultiplexFrameHeader(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : salted_service_id_hash_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+  , service_id_hash_salt_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
+struct MultiplexFrameHeaderDefaultTypeInternal {
+  constexpr MultiplexFrameHeaderDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~MultiplexFrameHeaderDefaultTypeInternal() {}
+  union {
+    MultiplexFrameHeader _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MultiplexFrameHeaderDefaultTypeInternal _MultiplexFrameHeader_default_instance_;
+constexpr MultiplexControlFrame::MultiplexControlFrame(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : control_frame_type_(0)
+
+  , _oneof_case_{}{}
+struct MultiplexControlFrameDefaultTypeInternal {
+  constexpr MultiplexControlFrameDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~MultiplexControlFrameDefaultTypeInternal() {}
+  union {
+    MultiplexControlFrame _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MultiplexControlFrameDefaultTypeInternal _MultiplexControlFrame_default_instance_;
+constexpr ConnectionRequestFrame::ConnectionRequestFrame(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
+struct ConnectionRequestFrameDefaultTypeInternal {
+  constexpr ConnectionRequestFrameDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~ConnectionRequestFrameDefaultTypeInternal() {}
+  union {
+    ConnectionRequestFrame _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ConnectionRequestFrameDefaultTypeInternal _ConnectionRequestFrame_default_instance_;
+constexpr ConnectionResponseFrame::ConnectionResponseFrame(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : connection_response_code_(0)
+{}
+struct ConnectionResponseFrameDefaultTypeInternal {
+  constexpr ConnectionResponseFrameDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~ConnectionResponseFrameDefaultTypeInternal() {}
+  union {
+    ConnectionResponseFrame _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ConnectionResponseFrameDefaultTypeInternal _ConnectionResponseFrame_default_instance_;
+constexpr DisconnectFrame::DisconnectFrame(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
+struct DisconnectFrameDefaultTypeInternal {
+  constexpr DisconnectFrameDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~DisconnectFrameDefaultTypeInternal() {}
+  union {
+    DisconnectFrame _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DisconnectFrameDefaultTypeInternal _DisconnectFrame_default_instance_;
+constexpr MultiplexDataFrame::MultiplexDataFrame(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : data_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
+struct MultiplexDataFrameDefaultTypeInternal {
+  constexpr MultiplexDataFrameDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~MultiplexDataFrameDefaultTypeInternal() {}
+  union {
+    MultiplexDataFrame _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MultiplexDataFrameDefaultTypeInternal _MultiplexDataFrame_default_instance_;
+}  // namespace mediums
+}  // namespace nearby
+}  // namespace location
+namespace location {
+namespace nearby {
+namespace mediums {
+bool MultiplexFrame_MultiplexFrameType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> MultiplexFrame_MultiplexFrameType_strings[3] = {};
+
+static const char MultiplexFrame_MultiplexFrameType_names[] =
+  "CONTROL_FRAME"
+  "DATA_FRAME"
+  "UNKNOWN_FRAME_TYPE";
+
+static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry MultiplexFrame_MultiplexFrameType_entries[] = {
+  { {MultiplexFrame_MultiplexFrameType_names + 0, 13}, 1 },
+  { {MultiplexFrame_MultiplexFrameType_names + 13, 10}, 2 },
+  { {MultiplexFrame_MultiplexFrameType_names + 23, 18}, 0 },
+};
+
+static const int MultiplexFrame_MultiplexFrameType_entries_by_number[] = {
+  2, // 0 -> UNKNOWN_FRAME_TYPE
+  0, // 1 -> CONTROL_FRAME
+  1, // 2 -> DATA_FRAME
+};
+
+const std::string& MultiplexFrame_MultiplexFrameType_Name(
+    MultiplexFrame_MultiplexFrameType value) {
+  static const bool dummy =
+      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
+          MultiplexFrame_MultiplexFrameType_entries,
+          MultiplexFrame_MultiplexFrameType_entries_by_number,
+          3, MultiplexFrame_MultiplexFrameType_strings);
+  (void) dummy;
+  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
+      MultiplexFrame_MultiplexFrameType_entries,
+      MultiplexFrame_MultiplexFrameType_entries_by_number,
+      3, value);
+  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
+                     MultiplexFrame_MultiplexFrameType_strings[idx].get();
+}
+bool MultiplexFrame_MultiplexFrameType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MultiplexFrame_MultiplexFrameType* value) {
+  int int_value;
+  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
+      MultiplexFrame_MultiplexFrameType_entries, 3, name, &int_value);
+  if (success) {
+    *value = static_cast<MultiplexFrame_MultiplexFrameType>(int_value);
+  }
+  return success;
+}
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr MultiplexFrame_MultiplexFrameType MultiplexFrame::UNKNOWN_FRAME_TYPE;
+constexpr MultiplexFrame_MultiplexFrameType MultiplexFrame::CONTROL_FRAME;
+constexpr MultiplexFrame_MultiplexFrameType MultiplexFrame::DATA_FRAME;
+constexpr MultiplexFrame_MultiplexFrameType MultiplexFrame::MultiplexFrameType_MIN;
+constexpr MultiplexFrame_MultiplexFrameType MultiplexFrame::MultiplexFrameType_MAX;
+constexpr int MultiplexFrame::MultiplexFrameType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+bool MultiplexControlFrame_MultiplexControlFrameType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+      return true;
+    default:
+      return false;
+  }
+}
+
+static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> MultiplexControlFrame_MultiplexControlFrameType_strings[4] = {};
+
+static const char MultiplexControlFrame_MultiplexControlFrameType_names[] =
+  "CONNECTION_REQUEST"
+  "CONNECTION_RESPONSE"
+  "DISCONNECTION"
+  "UNKNOWN_CONTROL_FRAME_TYPE";
+
+static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry MultiplexControlFrame_MultiplexControlFrameType_entries[] = {
+  { {MultiplexControlFrame_MultiplexControlFrameType_names + 0, 18}, 1 },
+  { {MultiplexControlFrame_MultiplexControlFrameType_names + 18, 19}, 2 },
+  { {MultiplexControlFrame_MultiplexControlFrameType_names + 37, 13}, 3 },
+  { {MultiplexControlFrame_MultiplexControlFrameType_names + 50, 26}, 0 },
+};
+
+static const int MultiplexControlFrame_MultiplexControlFrameType_entries_by_number[] = {
+  3, // 0 -> UNKNOWN_CONTROL_FRAME_TYPE
+  0, // 1 -> CONNECTION_REQUEST
+  1, // 2 -> CONNECTION_RESPONSE
+  2, // 3 -> DISCONNECTION
+};
+
+const std::string& MultiplexControlFrame_MultiplexControlFrameType_Name(
+    MultiplexControlFrame_MultiplexControlFrameType value) {
+  static const bool dummy =
+      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
+          MultiplexControlFrame_MultiplexControlFrameType_entries,
+          MultiplexControlFrame_MultiplexControlFrameType_entries_by_number,
+          4, MultiplexControlFrame_MultiplexControlFrameType_strings);
+  (void) dummy;
+  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
+      MultiplexControlFrame_MultiplexControlFrameType_entries,
+      MultiplexControlFrame_MultiplexControlFrameType_entries_by_number,
+      4, value);
+  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
+                     MultiplexControlFrame_MultiplexControlFrameType_strings[idx].get();
+}
+bool MultiplexControlFrame_MultiplexControlFrameType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MultiplexControlFrame_MultiplexControlFrameType* value) {
+  int int_value;
+  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
+      MultiplexControlFrame_MultiplexControlFrameType_entries, 4, name, &int_value);
+  if (success) {
+    *value = static_cast<MultiplexControlFrame_MultiplexControlFrameType>(int_value);
+  }
+  return success;
+}
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr MultiplexControlFrame_MultiplexControlFrameType MultiplexControlFrame::UNKNOWN_CONTROL_FRAME_TYPE;
+constexpr MultiplexControlFrame_MultiplexControlFrameType MultiplexControlFrame::CONNECTION_REQUEST;
+constexpr MultiplexControlFrame_MultiplexControlFrameType MultiplexControlFrame::CONNECTION_RESPONSE;
+constexpr MultiplexControlFrame_MultiplexControlFrameType MultiplexControlFrame::DISCONNECTION;
+constexpr MultiplexControlFrame_MultiplexControlFrameType MultiplexControlFrame::MultiplexControlFrameType_MIN;
+constexpr MultiplexControlFrame_MultiplexControlFrameType MultiplexControlFrame::MultiplexControlFrameType_MAX;
+constexpr int MultiplexControlFrame::MultiplexControlFrameType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+bool ConnectionResponseFrame_ConnectionResponseCode_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ConnectionResponseFrame_ConnectionResponseCode_strings[3] = {};
+
+static const char ConnectionResponseFrame_ConnectionResponseCode_names[] =
+  "CONNECTION_ACCEPTED"
+  "NOT_LISTENING"
+  "UNKNOWN_RESPONSE_CODE";
+
+static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ConnectionResponseFrame_ConnectionResponseCode_entries[] = {
+  { {ConnectionResponseFrame_ConnectionResponseCode_names + 0, 19}, 1 },
+  { {ConnectionResponseFrame_ConnectionResponseCode_names + 19, 13}, 2 },
+  { {ConnectionResponseFrame_ConnectionResponseCode_names + 32, 21}, 0 },
+};
+
+static const int ConnectionResponseFrame_ConnectionResponseCode_entries_by_number[] = {
+  2, // 0 -> UNKNOWN_RESPONSE_CODE
+  0, // 1 -> CONNECTION_ACCEPTED
+  1, // 2 -> NOT_LISTENING
+};
+
+const std::string& ConnectionResponseFrame_ConnectionResponseCode_Name(
+    ConnectionResponseFrame_ConnectionResponseCode value) {
+  static const bool dummy =
+      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
+          ConnectionResponseFrame_ConnectionResponseCode_entries,
+          ConnectionResponseFrame_ConnectionResponseCode_entries_by_number,
+          3, ConnectionResponseFrame_ConnectionResponseCode_strings);
+  (void) dummy;
+  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
+      ConnectionResponseFrame_ConnectionResponseCode_entries,
+      ConnectionResponseFrame_ConnectionResponseCode_entries_by_number,
+      3, value);
+  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
+                     ConnectionResponseFrame_ConnectionResponseCode_strings[idx].get();
+}
+bool ConnectionResponseFrame_ConnectionResponseCode_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConnectionResponseFrame_ConnectionResponseCode* value) {
+  int int_value;
+  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
+      ConnectionResponseFrame_ConnectionResponseCode_entries, 3, name, &int_value);
+  if (success) {
+    *value = static_cast<ConnectionResponseFrame_ConnectionResponseCode>(int_value);
+  }
+  return success;
+}
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr ConnectionResponseFrame_ConnectionResponseCode ConnectionResponseFrame::UNKNOWN_RESPONSE_CODE;
+constexpr ConnectionResponseFrame_ConnectionResponseCode ConnectionResponseFrame::CONNECTION_ACCEPTED;
+constexpr ConnectionResponseFrame_ConnectionResponseCode ConnectionResponseFrame::NOT_LISTENING;
+constexpr ConnectionResponseFrame_ConnectionResponseCode ConnectionResponseFrame::ConnectionResponseCode_MIN;
+constexpr ConnectionResponseFrame_ConnectionResponseCode ConnectionResponseFrame::ConnectionResponseCode_MAX;
+constexpr int ConnectionResponseFrame::ConnectionResponseCode_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+
+// ===================================================================
+
+class MultiplexFrame::_Internal {
+ public:
+  using HasBits = decltype(std::declval<MultiplexFrame>()._has_bits_);
+  static const ::location::nearby::mediums::MultiplexFrameHeader& header(const MultiplexFrame* msg);
+  static void set_has_header(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_frame_type(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::location::nearby::mediums::MultiplexControlFrame& control_frame(const MultiplexFrame* msg);
+  static const ::location::nearby::mediums::MultiplexDataFrame& data_frame(const MultiplexFrame* msg);
+};
+
+const ::location::nearby::mediums::MultiplexFrameHeader&
+MultiplexFrame::_Internal::header(const MultiplexFrame* msg) {
+  return *msg->header_;
+}
+const ::location::nearby::mediums::MultiplexControlFrame&
+MultiplexFrame::_Internal::control_frame(const MultiplexFrame* msg) {
+  return *msg->Frame_.control_frame_;
+}
+const ::location::nearby::mediums::MultiplexDataFrame&
+MultiplexFrame::_Internal::data_frame(const MultiplexFrame* msg) {
+  return *msg->Frame_.data_frame_;
+}
+void MultiplexFrame::set_allocated_control_frame(::location::nearby::mediums::MultiplexControlFrame* control_frame) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_Frame();
+  if (control_frame) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::mediums::MultiplexControlFrame>::GetOwningArena(control_frame);
+    if (message_arena != submessage_arena) {
+      control_frame = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, control_frame, submessage_arena);
+    }
+    set_has_control_frame();
+    Frame_.control_frame_ = control_frame;
+  }
+  // @@protoc_insertion_point(field_set_allocated:location.nearby.mediums.MultiplexFrame.control_frame)
+}
+void MultiplexFrame::set_allocated_data_frame(::location::nearby::mediums::MultiplexDataFrame* data_frame) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_Frame();
+  if (data_frame) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::mediums::MultiplexDataFrame>::GetOwningArena(data_frame);
+    if (message_arena != submessage_arena) {
+      data_frame = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, data_frame, submessage_arena);
+    }
+    set_has_data_frame();
+    Frame_.data_frame_ = data_frame;
+  }
+  // @@protoc_insertion_point(field_set_allocated:location.nearby.mediums.MultiplexFrame.data_frame)
+}
+MultiplexFrame::MultiplexFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:location.nearby.mediums.MultiplexFrame)
+}
+MultiplexFrame::MultiplexFrame(const MultiplexFrame& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
+      _has_bits_(from._has_bits_) {
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  if (from._internal_has_header()) {
+    header_ = new ::location::nearby::mediums::MultiplexFrameHeader(*from.header_);
+  } else {
+    header_ = nullptr;
+  }
+  frame_type_ = from.frame_type_;
+  clear_has_Frame();
+  switch (from.Frame_case()) {
+    case kControlFrame: {
+      _internal_mutable_control_frame()->::location::nearby::mediums::MultiplexControlFrame::MergeFrom(from._internal_control_frame());
+      break;
+    }
+    case kDataFrame: {
+      _internal_mutable_data_frame()->::location::nearby::mediums::MultiplexDataFrame::MergeFrom(from._internal_data_frame());
+      break;
+    }
+    case FRAME_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:location.nearby.mediums.MultiplexFrame)
+}
+
+inline void MultiplexFrame::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&header_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&frame_type_) -
+    reinterpret_cast<char*>(&header_)) + sizeof(frame_type_));
+clear_has_Frame();
+}
+
+MultiplexFrame::~MultiplexFrame() {
+  // @@protoc_insertion_point(destructor:location.nearby.mediums.MultiplexFrame)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<std::string>();
+}
+
+inline void MultiplexFrame::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete header_;
+  if (has_Frame()) {
+    clear_Frame();
+  }
+}
+
+void MultiplexFrame::ArenaDtor(void* object) {
+  MultiplexFrame* _this = reinterpret_cast< MultiplexFrame* >(object);
+  (void)_this;
+}
+void MultiplexFrame::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void MultiplexFrame::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void MultiplexFrame::clear_Frame() {
+// @@protoc_insertion_point(one_of_clear_start:location.nearby.mediums.MultiplexFrame)
+  switch (Frame_case()) {
+    case kControlFrame: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete Frame_.control_frame_;
+      }
+      break;
+    }
+    case kDataFrame: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete Frame_.data_frame_;
+      }
+      break;
+    }
+    case FRAME_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = FRAME_NOT_SET;
+}
+
+
+void MultiplexFrame::Clear() {
+// @@protoc_insertion_point(message_clear_start:location.nearby.mediums.MultiplexFrame)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    GOOGLE_DCHECK(header_ != nullptr);
+    header_->Clear();
+  }
+  frame_type_ = 0;
+  clear_Frame();
+  _has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* MultiplexFrame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .location.nearby.mediums.MultiplexFrameHeader header = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_header(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .location.nearby.mediums.MultiplexFrame.MultiplexFrameType frame_type = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::location::nearby::mediums::MultiplexFrame_MultiplexFrameType_IsValid(val))) {
+            _internal_set_frame_type(static_cast<::location::nearby::mediums::MultiplexFrame_MultiplexFrameType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // .location.nearby.mediums.MultiplexControlFrame control_frame = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_control_frame(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .location.nearby.mediums.MultiplexDataFrame data_frame = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_data_frame(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* MultiplexFrame::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:location.nearby.mediums.MultiplexFrame)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  // optional .location.nearby.mediums.MultiplexFrameHeader header = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::header(this), target, stream);
+  }
+
+  // optional .location.nearby.mediums.MultiplexFrame.MultiplexFrameType frame_type = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_frame_type(), target);
+  }
+
+  switch (Frame_case()) {
+    case kControlFrame: {
+      target = stream->EnsureSpace(target);
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(
+          3, _Internal::control_frame(this), target, stream);
+      break;
+    }
+    case kDataFrame: {
+      target = stream->EnsureSpace(target);
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(
+          4, _Internal::data_frame(this), target, stream);
+      break;
+    }
+    default: ;
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:location.nearby.mediums.MultiplexFrame)
+  return target;
+}
+
+size_t MultiplexFrame::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:location.nearby.mediums.MultiplexFrame)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional .location.nearby.mediums.MultiplexFrameHeader header = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *header_);
+    }
+
+    // optional .location.nearby.mediums.MultiplexFrame.MultiplexFrameType frame_type = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_frame_type());
+    }
+
+  }
+  switch (Frame_case()) {
+    // .location.nearby.mediums.MultiplexControlFrame control_frame = 3;
+    case kControlFrame: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *Frame_.control_frame_);
+      break;
+    }
+    // .location.nearby.mediums.MultiplexDataFrame data_frame = 4;
+    case kDataFrame: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *Frame_.data_frame_);
+      break;
+    }
+    case FRAME_NOT_SET: {
+      break;
+    }
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void MultiplexFrame::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MultiplexFrame*>(
+      &from));
+}
+
+void MultiplexFrame::MergeFrom(const MultiplexFrame& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.mediums.MultiplexFrame)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _internal_mutable_header()->::location::nearby::mediums::MultiplexFrameHeader::MergeFrom(from._internal_header());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      frame_type_ = from.frame_type_;
+    }
+    _has_bits_[0] |= cached_has_bits;
+  }
+  switch (from.Frame_case()) {
+    case kControlFrame: {
+      _internal_mutable_control_frame()->::location::nearby::mediums::MultiplexControlFrame::MergeFrom(from._internal_control_frame());
+      break;
+    }
+    case kDataFrame: {
+      _internal_mutable_data_frame()->::location::nearby::mediums::MultiplexDataFrame::MergeFrom(from._internal_data_frame());
+      break;
+    }
+    case FRAME_NOT_SET: {
+      break;
+    }
+  }
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void MultiplexFrame::CopyFrom(const MultiplexFrame& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.mediums.MultiplexFrame)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool MultiplexFrame::IsInitialized() const {
+  return true;
+}
+
+void MultiplexFrame::InternalSwap(MultiplexFrame* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_has_bits_[0], other->_has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(MultiplexFrame, frame_type_)
+      + sizeof(MultiplexFrame::frame_type_)
+      - PROTOBUF_FIELD_OFFSET(MultiplexFrame, header_)>(
+          reinterpret_cast<char*>(&header_),
+          reinterpret_cast<char*>(&other->header_));
+  swap(Frame_, other->Frame_);
+  swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+std::string MultiplexFrame::GetTypeName() const {
+  return "location.nearby.mediums.MultiplexFrame";
+}
+
+
+// ===================================================================
+
+class MultiplexFrameHeader::_Internal {
+ public:
+  using HasBits = decltype(std::declval<MultiplexFrameHeader>()._has_bits_);
+  static void set_has_salted_service_id_hash(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_service_id_hash_salt(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+MultiplexFrameHeader::MultiplexFrameHeader(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:location.nearby.mediums.MultiplexFrameHeader)
+}
+MultiplexFrameHeader::MultiplexFrameHeader(const MultiplexFrameHeader& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
+      _has_bits_(from._has_bits_) {
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  salted_service_id_hash_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    salted_service_id_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_salted_service_id_hash()) {
+    salted_service_id_hash_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_salted_service_id_hash(), 
+      GetArenaForAllocation());
+  }
+  service_id_hash_salt_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    service_id_hash_salt_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_service_id_hash_salt()) {
+    service_id_hash_salt_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_service_id_hash_salt(), 
+      GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:location.nearby.mediums.MultiplexFrameHeader)
+}
+
+inline void MultiplexFrameHeader::SharedCtor() {
+salted_service_id_hash_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  salted_service_id_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+service_id_hash_salt_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  service_id_hash_salt_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+MultiplexFrameHeader::~MultiplexFrameHeader() {
+  // @@protoc_insertion_point(destructor:location.nearby.mediums.MultiplexFrameHeader)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<std::string>();
+}
+
+inline void MultiplexFrameHeader::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  salted_service_id_hash_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  service_id_hash_salt_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void MultiplexFrameHeader::ArenaDtor(void* object) {
+  MultiplexFrameHeader* _this = reinterpret_cast< MultiplexFrameHeader* >(object);
+  (void)_this;
+}
+void MultiplexFrameHeader::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void MultiplexFrameHeader::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void MultiplexFrameHeader::Clear() {
+// @@protoc_insertion_point(message_clear_start:location.nearby.mediums.MultiplexFrameHeader)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      salted_service_id_hash_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      service_id_hash_salt_.ClearNonDefaultToEmpty();
+    }
+  }
+  _has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* MultiplexFrameHeader::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes salted_service_id_hash = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_salted_service_id_hash();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string service_id_hash_salt = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_service_id_hash_salt();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* MultiplexFrameHeader::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:location.nearby.mediums.MultiplexFrameHeader)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  // optional bytes salted_service_id_hash = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_salted_service_id_hash(), target);
+  }
+
+  // optional string service_id_hash_salt = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_service_id_hash_salt(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:location.nearby.mediums.MultiplexFrameHeader)
+  return target;
+}
+
+size_t MultiplexFrameHeader::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:location.nearby.mediums.MultiplexFrameHeader)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional bytes salted_service_id_hash = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_salted_service_id_hash());
+    }
+
+    // optional string service_id_hash_salt = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_service_id_hash_salt());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void MultiplexFrameHeader::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MultiplexFrameHeader*>(
+      &from));
+}
+
+void MultiplexFrameHeader::MergeFrom(const MultiplexFrameHeader& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.mediums.MultiplexFrameHeader)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _internal_set_salted_service_id_hash(from._internal_salted_service_id_hash());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _internal_set_service_id_hash_salt(from._internal_service_id_hash_salt());
+    }
+  }
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void MultiplexFrameHeader::CopyFrom(const MultiplexFrameHeader& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.mediums.MultiplexFrameHeader)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool MultiplexFrameHeader::IsInitialized() const {
+  return true;
+}
+
+void MultiplexFrameHeader::InternalSwap(MultiplexFrameHeader* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_has_bits_[0], other->_has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      &salted_service_id_hash_, lhs_arena,
+      &other->salted_service_id_hash_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      &service_id_hash_salt_, lhs_arena,
+      &other->service_id_hash_salt_, rhs_arena
+  );
+}
+
+std::string MultiplexFrameHeader::GetTypeName() const {
+  return "location.nearby.mediums.MultiplexFrameHeader";
+}
+
+
+// ===================================================================
+
+class MultiplexControlFrame::_Internal {
+ public:
+  using HasBits = decltype(std::declval<MultiplexControlFrame>()._has_bits_);
+  static void set_has_control_frame_type(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::location::nearby::mediums::ConnectionRequestFrame& connection_request_frame(const MultiplexControlFrame* msg);
+  static const ::location::nearby::mediums::ConnectionResponseFrame& connection_response_frame(const MultiplexControlFrame* msg);
+  static const ::location::nearby::mediums::DisconnectFrame& disconnect_frame(const MultiplexControlFrame* msg);
+};
+
+const ::location::nearby::mediums::ConnectionRequestFrame&
+MultiplexControlFrame::_Internal::connection_request_frame(const MultiplexControlFrame* msg) {
+  return *msg->Frame_.connection_request_frame_;
+}
+const ::location::nearby::mediums::ConnectionResponseFrame&
+MultiplexControlFrame::_Internal::connection_response_frame(const MultiplexControlFrame* msg) {
+  return *msg->Frame_.connection_response_frame_;
+}
+const ::location::nearby::mediums::DisconnectFrame&
+MultiplexControlFrame::_Internal::disconnect_frame(const MultiplexControlFrame* msg) {
+  return *msg->Frame_.disconnect_frame_;
+}
+void MultiplexControlFrame::set_allocated_connection_request_frame(::location::nearby::mediums::ConnectionRequestFrame* connection_request_frame) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_Frame();
+  if (connection_request_frame) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::mediums::ConnectionRequestFrame>::GetOwningArena(connection_request_frame);
+    if (message_arena != submessage_arena) {
+      connection_request_frame = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, connection_request_frame, submessage_arena);
+    }
+    set_has_connection_request_frame();
+    Frame_.connection_request_frame_ = connection_request_frame;
+  }
+  // @@protoc_insertion_point(field_set_allocated:location.nearby.mediums.MultiplexControlFrame.connection_request_frame)
+}
+void MultiplexControlFrame::set_allocated_connection_response_frame(::location::nearby::mediums::ConnectionResponseFrame* connection_response_frame) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_Frame();
+  if (connection_response_frame) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::mediums::ConnectionResponseFrame>::GetOwningArena(connection_response_frame);
+    if (message_arena != submessage_arena) {
+      connection_response_frame = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, connection_response_frame, submessage_arena);
+    }
+    set_has_connection_response_frame();
+    Frame_.connection_response_frame_ = connection_response_frame;
+  }
+  // @@protoc_insertion_point(field_set_allocated:location.nearby.mediums.MultiplexControlFrame.connection_response_frame)
+}
+void MultiplexControlFrame::set_allocated_disconnect_frame(::location::nearby::mediums::DisconnectFrame* disconnect_frame) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_Frame();
+  if (disconnect_frame) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::mediums::DisconnectFrame>::GetOwningArena(disconnect_frame);
+    if (message_arena != submessage_arena) {
+      disconnect_frame = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, disconnect_frame, submessage_arena);
+    }
+    set_has_disconnect_frame();
+    Frame_.disconnect_frame_ = disconnect_frame;
+  }
+  // @@protoc_insertion_point(field_set_allocated:location.nearby.mediums.MultiplexControlFrame.disconnect_frame)
+}
+MultiplexControlFrame::MultiplexControlFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:location.nearby.mediums.MultiplexControlFrame)
+}
+MultiplexControlFrame::MultiplexControlFrame(const MultiplexControlFrame& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
+      _has_bits_(from._has_bits_) {
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  control_frame_type_ = from.control_frame_type_;
+  clear_has_Frame();
+  switch (from.Frame_case()) {
+    case kConnectionRequestFrame: {
+      _internal_mutable_connection_request_frame()->::location::nearby::mediums::ConnectionRequestFrame::MergeFrom(from._internal_connection_request_frame());
+      break;
+    }
+    case kConnectionResponseFrame: {
+      _internal_mutable_connection_response_frame()->::location::nearby::mediums::ConnectionResponseFrame::MergeFrom(from._internal_connection_response_frame());
+      break;
+    }
+    case kDisconnectFrame: {
+      _internal_mutable_disconnect_frame()->::location::nearby::mediums::DisconnectFrame::MergeFrom(from._internal_disconnect_frame());
+      break;
+    }
+    case FRAME_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:location.nearby.mediums.MultiplexControlFrame)
+}
+
+inline void MultiplexControlFrame::SharedCtor() {
+control_frame_type_ = 0;
+clear_has_Frame();
+}
+
+MultiplexControlFrame::~MultiplexControlFrame() {
+  // @@protoc_insertion_point(destructor:location.nearby.mediums.MultiplexControlFrame)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<std::string>();
+}
+
+inline void MultiplexControlFrame::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (has_Frame()) {
+    clear_Frame();
+  }
+}
+
+void MultiplexControlFrame::ArenaDtor(void* object) {
+  MultiplexControlFrame* _this = reinterpret_cast< MultiplexControlFrame* >(object);
+  (void)_this;
+}
+void MultiplexControlFrame::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void MultiplexControlFrame::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void MultiplexControlFrame::clear_Frame() {
+// @@protoc_insertion_point(one_of_clear_start:location.nearby.mediums.MultiplexControlFrame)
+  switch (Frame_case()) {
+    case kConnectionRequestFrame: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete Frame_.connection_request_frame_;
+      }
+      break;
+    }
+    case kConnectionResponseFrame: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete Frame_.connection_response_frame_;
+      }
+      break;
+    }
+    case kDisconnectFrame: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete Frame_.disconnect_frame_;
+      }
+      break;
+    }
+    case FRAME_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = FRAME_NOT_SET;
+}
+
+
+void MultiplexControlFrame::Clear() {
+// @@protoc_insertion_point(message_clear_start:location.nearby.mediums.MultiplexControlFrame)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  control_frame_type_ = 0;
+  clear_Frame();
+  _has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* MultiplexControlFrame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .location.nearby.mediums.MultiplexControlFrame.MultiplexControlFrameType control_frame_type = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::location::nearby::mediums::MultiplexControlFrame_MultiplexControlFrameType_IsValid(val))) {
+            _internal_set_control_frame_type(static_cast<::location::nearby::mediums::MultiplexControlFrame_MultiplexControlFrameType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // .location.nearby.mediums.ConnectionRequestFrame connection_request_frame = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_connection_request_frame(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .location.nearby.mediums.ConnectionResponseFrame connection_response_frame = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_connection_response_frame(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .location.nearby.mediums.DisconnectFrame disconnect_frame = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_disconnect_frame(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* MultiplexControlFrame::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:location.nearby.mediums.MultiplexControlFrame)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  // optional .location.nearby.mediums.MultiplexControlFrame.MultiplexControlFrameType control_frame_type = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      1, this->_internal_control_frame_type(), target);
+  }
+
+  switch (Frame_case()) {
+    case kConnectionRequestFrame: {
+      target = stream->EnsureSpace(target);
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(
+          2, _Internal::connection_request_frame(this), target, stream);
+      break;
+    }
+    case kConnectionResponseFrame: {
+      target = stream->EnsureSpace(target);
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(
+          3, _Internal::connection_response_frame(this), target, stream);
+      break;
+    }
+    case kDisconnectFrame: {
+      target = stream->EnsureSpace(target);
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(
+          4, _Internal::disconnect_frame(this), target, stream);
+      break;
+    }
+    default: ;
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:location.nearby.mediums.MultiplexControlFrame)
+  return target;
+}
+
+size_t MultiplexControlFrame::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:location.nearby.mediums.MultiplexControlFrame)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional .location.nearby.mediums.MultiplexControlFrame.MultiplexControlFrameType control_frame_type = 1;
+  cached_has_bits = _has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_control_frame_type());
+  }
+
+  switch (Frame_case()) {
+    // .location.nearby.mediums.ConnectionRequestFrame connection_request_frame = 2;
+    case kConnectionRequestFrame: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *Frame_.connection_request_frame_);
+      break;
+    }
+    // .location.nearby.mediums.ConnectionResponseFrame connection_response_frame = 3;
+    case kConnectionResponseFrame: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *Frame_.connection_response_frame_);
+      break;
+    }
+    // .location.nearby.mediums.DisconnectFrame disconnect_frame = 4;
+    case kDisconnectFrame: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *Frame_.disconnect_frame_);
+      break;
+    }
+    case FRAME_NOT_SET: {
+      break;
+    }
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void MultiplexControlFrame::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MultiplexControlFrame*>(
+      &from));
+}
+
+void MultiplexControlFrame::MergeFrom(const MultiplexControlFrame& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.mediums.MultiplexControlFrame)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_control_frame_type()) {
+    _internal_set_control_frame_type(from._internal_control_frame_type());
+  }
+  switch (from.Frame_case()) {
+    case kConnectionRequestFrame: {
+      _internal_mutable_connection_request_frame()->::location::nearby::mediums::ConnectionRequestFrame::MergeFrom(from._internal_connection_request_frame());
+      break;
+    }
+    case kConnectionResponseFrame: {
+      _internal_mutable_connection_response_frame()->::location::nearby::mediums::ConnectionResponseFrame::MergeFrom(from._internal_connection_response_frame());
+      break;
+    }
+    case kDisconnectFrame: {
+      _internal_mutable_disconnect_frame()->::location::nearby::mediums::DisconnectFrame::MergeFrom(from._internal_disconnect_frame());
+      break;
+    }
+    case FRAME_NOT_SET: {
+      break;
+    }
+  }
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void MultiplexControlFrame::CopyFrom(const MultiplexControlFrame& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.mediums.MultiplexControlFrame)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool MultiplexControlFrame::IsInitialized() const {
+  return true;
+}
+
+void MultiplexControlFrame::InternalSwap(MultiplexControlFrame* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_has_bits_[0], other->_has_bits_[0]);
+  swap(control_frame_type_, other->control_frame_type_);
+  swap(Frame_, other->Frame_);
+  swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+std::string MultiplexControlFrame::GetTypeName() const {
+  return "location.nearby.mediums.MultiplexControlFrame";
+}
+
+
+// ===================================================================
+
+class ConnectionRequestFrame::_Internal {
+ public:
+};
+
+ConnectionRequestFrame::ConnectionRequestFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:location.nearby.mediums.ConnectionRequestFrame)
+}
+ConnectionRequestFrame::ConnectionRequestFrame(const ConnectionRequestFrame& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:location.nearby.mediums.ConnectionRequestFrame)
+}
+
+inline void ConnectionRequestFrame::SharedCtor() {
+}
+
+ConnectionRequestFrame::~ConnectionRequestFrame() {
+  // @@protoc_insertion_point(destructor:location.nearby.mediums.ConnectionRequestFrame)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<std::string>();
+}
+
+inline void ConnectionRequestFrame::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void ConnectionRequestFrame::ArenaDtor(void* object) {
+  ConnectionRequestFrame* _this = reinterpret_cast< ConnectionRequestFrame* >(object);
+  (void)_this;
+}
+void ConnectionRequestFrame::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void ConnectionRequestFrame::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void ConnectionRequestFrame::Clear() {
+// @@protoc_insertion_point(message_clear_start:location.nearby.mediums.ConnectionRequestFrame)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ConnectionRequestFrame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ConnectionRequestFrame::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:location.nearby.mediums.ConnectionRequestFrame)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:location.nearby.mediums.ConnectionRequestFrame)
+  return target;
+}
+
+size_t ConnectionRequestFrame::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:location.nearby.mediums.ConnectionRequestFrame)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ConnectionRequestFrame::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ConnectionRequestFrame*>(
+      &from));
+}
+
+void ConnectionRequestFrame::MergeFrom(const ConnectionRequestFrame& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.mediums.ConnectionRequestFrame)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ConnectionRequestFrame::CopyFrom(const ConnectionRequestFrame& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.mediums.ConnectionRequestFrame)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ConnectionRequestFrame::IsInitialized() const {
+  return true;
+}
+
+void ConnectionRequestFrame::InternalSwap(ConnectionRequestFrame* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+}
+
+std::string ConnectionRequestFrame::GetTypeName() const {
+  return "location.nearby.mediums.ConnectionRequestFrame";
+}
+
+
+// ===================================================================
+
+class ConnectionResponseFrame::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ConnectionResponseFrame>()._has_bits_);
+  static void set_has_connection_response_code(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+ConnectionResponseFrame::ConnectionResponseFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:location.nearby.mediums.ConnectionResponseFrame)
+}
+ConnectionResponseFrame::ConnectionResponseFrame(const ConnectionResponseFrame& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
+      _has_bits_(from._has_bits_) {
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  connection_response_code_ = from.connection_response_code_;
+  // @@protoc_insertion_point(copy_constructor:location.nearby.mediums.ConnectionResponseFrame)
+}
+
+inline void ConnectionResponseFrame::SharedCtor() {
+connection_response_code_ = 0;
+}
+
+ConnectionResponseFrame::~ConnectionResponseFrame() {
+  // @@protoc_insertion_point(destructor:location.nearby.mediums.ConnectionResponseFrame)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<std::string>();
+}
+
+inline void ConnectionResponseFrame::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void ConnectionResponseFrame::ArenaDtor(void* object) {
+  ConnectionResponseFrame* _this = reinterpret_cast< ConnectionResponseFrame* >(object);
+  (void)_this;
+}
+void ConnectionResponseFrame::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void ConnectionResponseFrame::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void ConnectionResponseFrame::Clear() {
+// @@protoc_insertion_point(message_clear_start:location.nearby.mediums.ConnectionResponseFrame)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  connection_response_code_ = 0;
+  _has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ConnectionResponseFrame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .location.nearby.mediums.ConnectionResponseFrame.ConnectionResponseCode connection_response_code = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::location::nearby::mediums::ConnectionResponseFrame_ConnectionResponseCode_IsValid(val))) {
+            _internal_set_connection_response_code(static_cast<::location::nearby::mediums::ConnectionResponseFrame_ConnectionResponseCode>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ConnectionResponseFrame::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:location.nearby.mediums.ConnectionResponseFrame)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  // optional .location.nearby.mediums.ConnectionResponseFrame.ConnectionResponseCode connection_response_code = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      1, this->_internal_connection_response_code(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:location.nearby.mediums.ConnectionResponseFrame)
+  return target;
+}
+
+size_t ConnectionResponseFrame::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:location.nearby.mediums.ConnectionResponseFrame)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional .location.nearby.mediums.ConnectionResponseFrame.ConnectionResponseCode connection_response_code = 1;
+  cached_has_bits = _has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_connection_response_code());
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ConnectionResponseFrame::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ConnectionResponseFrame*>(
+      &from));
+}
+
+void ConnectionResponseFrame::MergeFrom(const ConnectionResponseFrame& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.mediums.ConnectionResponseFrame)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_connection_response_code()) {
+    _internal_set_connection_response_code(from._internal_connection_response_code());
+  }
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ConnectionResponseFrame::CopyFrom(const ConnectionResponseFrame& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.mediums.ConnectionResponseFrame)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ConnectionResponseFrame::IsInitialized() const {
+  return true;
+}
+
+void ConnectionResponseFrame::InternalSwap(ConnectionResponseFrame* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_has_bits_[0], other->_has_bits_[0]);
+  swap(connection_response_code_, other->connection_response_code_);
+}
+
+std::string ConnectionResponseFrame::GetTypeName() const {
+  return "location.nearby.mediums.ConnectionResponseFrame";
+}
+
+
+// ===================================================================
+
+class DisconnectFrame::_Internal {
+ public:
+};
+
+DisconnectFrame::DisconnectFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:location.nearby.mediums.DisconnectFrame)
+}
+DisconnectFrame::DisconnectFrame(const DisconnectFrame& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:location.nearby.mediums.DisconnectFrame)
+}
+
+inline void DisconnectFrame::SharedCtor() {
+}
+
+DisconnectFrame::~DisconnectFrame() {
+  // @@protoc_insertion_point(destructor:location.nearby.mediums.DisconnectFrame)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<std::string>();
+}
+
+inline void DisconnectFrame::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void DisconnectFrame::ArenaDtor(void* object) {
+  DisconnectFrame* _this = reinterpret_cast< DisconnectFrame* >(object);
+  (void)_this;
+}
+void DisconnectFrame::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void DisconnectFrame::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void DisconnectFrame::Clear() {
+// @@protoc_insertion_point(message_clear_start:location.nearby.mediums.DisconnectFrame)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* DisconnectFrame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* DisconnectFrame::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:location.nearby.mediums.DisconnectFrame)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:location.nearby.mediums.DisconnectFrame)
+  return target;
+}
+
+size_t DisconnectFrame::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:location.nearby.mediums.DisconnectFrame)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void DisconnectFrame::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const DisconnectFrame*>(
+      &from));
+}
+
+void DisconnectFrame::MergeFrom(const DisconnectFrame& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.mediums.DisconnectFrame)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void DisconnectFrame::CopyFrom(const DisconnectFrame& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.mediums.DisconnectFrame)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DisconnectFrame::IsInitialized() const {
+  return true;
+}
+
+void DisconnectFrame::InternalSwap(DisconnectFrame* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+}
+
+std::string DisconnectFrame::GetTypeName() const {
+  return "location.nearby.mediums.DisconnectFrame";
+}
+
+
+// ===================================================================
+
+class MultiplexDataFrame::_Internal {
+ public:
+  using HasBits = decltype(std::declval<MultiplexDataFrame>()._has_bits_);
+  static void set_has_data(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+MultiplexDataFrame::MultiplexDataFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:location.nearby.mediums.MultiplexDataFrame)
+}
+MultiplexDataFrame::MultiplexDataFrame(const MultiplexDataFrame& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
+      _has_bits_(from._has_bits_) {
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_data()) {
+    data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_data(), 
+      GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:location.nearby.mediums.MultiplexDataFrame)
+}
+
+inline void MultiplexDataFrame::SharedCtor() {
+data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+MultiplexDataFrame::~MultiplexDataFrame() {
+  // @@protoc_insertion_point(destructor:location.nearby.mediums.MultiplexDataFrame)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<std::string>();
+}
+
+inline void MultiplexDataFrame::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void MultiplexDataFrame::ArenaDtor(void* object) {
+  MultiplexDataFrame* _this = reinterpret_cast< MultiplexDataFrame* >(object);
+  (void)_this;
+}
+void MultiplexDataFrame::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void MultiplexDataFrame::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void MultiplexDataFrame::Clear() {
+// @@protoc_insertion_point(message_clear_start:location.nearby.mediums.MultiplexDataFrame)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    data_.ClearNonDefaultToEmpty();
+  }
+  _has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* MultiplexDataFrame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes data = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_data();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* MultiplexDataFrame::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:location.nearby.mediums.MultiplexDataFrame)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  // optional bytes data = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_data(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:location.nearby.mediums.MultiplexDataFrame)
+  return target;
+}
+
+size_t MultiplexDataFrame::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:location.nearby.mediums.MultiplexDataFrame)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional bytes data = 1;
+  cached_has_bits = _has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+        this->_internal_data());
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void MultiplexDataFrame::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MultiplexDataFrame*>(
+      &from));
+}
+
+void MultiplexDataFrame::MergeFrom(const MultiplexDataFrame& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.mediums.MultiplexDataFrame)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_data()) {
+    _internal_set_data(from._internal_data());
+  }
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void MultiplexDataFrame::CopyFrom(const MultiplexDataFrame& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.mediums.MultiplexDataFrame)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool MultiplexDataFrame::IsInitialized() const {
+  return true;
+}
+
+void MultiplexDataFrame::InternalSwap(MultiplexDataFrame* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_has_bits_[0], other->_has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      &data_, lhs_arena,
+      &other->data_, rhs_arena
+  );
+}
+
+std::string MultiplexDataFrame::GetTypeName() const {
+  return "location.nearby.mediums.MultiplexDataFrame";
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+}  // namespace mediums
+}  // namespace nearby
+}  // namespace location
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_NOINLINE ::location::nearby::mediums::MultiplexFrame* Arena::CreateMaybeMessage< ::location::nearby::mediums::MultiplexFrame >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::location::nearby::mediums::MultiplexFrame >(arena);
+}
+template<> PROTOBUF_NOINLINE ::location::nearby::mediums::MultiplexFrameHeader* Arena::CreateMaybeMessage< ::location::nearby::mediums::MultiplexFrameHeader >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::location::nearby::mediums::MultiplexFrameHeader >(arena);
+}
+template<> PROTOBUF_NOINLINE ::location::nearby::mediums::MultiplexControlFrame* Arena::CreateMaybeMessage< ::location::nearby::mediums::MultiplexControlFrame >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::location::nearby::mediums::MultiplexControlFrame >(arena);
+}
+template<> PROTOBUF_NOINLINE ::location::nearby::mediums::ConnectionRequestFrame* Arena::CreateMaybeMessage< ::location::nearby::mediums::ConnectionRequestFrame >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::location::nearby::mediums::ConnectionRequestFrame >(arena);
+}
+template<> PROTOBUF_NOINLINE ::location::nearby::mediums::ConnectionResponseFrame* Arena::CreateMaybeMessage< ::location::nearby::mediums::ConnectionResponseFrame >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::location::nearby::mediums::ConnectionResponseFrame >(arena);
+}
+template<> PROTOBUF_NOINLINE ::location::nearby::mediums::DisconnectFrame* Arena::CreateMaybeMessage< ::location::nearby::mediums::DisconnectFrame >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::location::nearby::mediums::DisconnectFrame >(arena);
+}
+template<> PROTOBUF_NOINLINE ::location::nearby::mediums::MultiplexDataFrame* Arena::CreateMaybeMessage< ::location::nearby::mediums::MultiplexDataFrame >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::location::nearby::mediums::MultiplexDataFrame >(arena);
+}
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+#include <google/protobuf/port_undef.inc>
diff --git a/compiled_proto/proto/mediums/multiplex_frames.pb.h b/compiled_proto/proto/mediums/multiplex_frames.pb.h
new file mode 100644
index 00000000..ba90a48e
--- /dev/null
+++ b/compiled_proto/proto/mediums/multiplex_frames.pb.h
@@ -0,0 +1,2229 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: proto/mediums/multiplex_frames.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_proto_2fmediums_2fmultiplex_5fframes_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_proto_2fmediums_2fmultiplex_5fframes_2eproto
+
+#include <limits>
+#include <string>
+
+#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.
+#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/message_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>
+#define PROTOBUF_INTERNAL_EXPORT_proto_2fmediums_2fmultiplex_5fframes_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_proto_2fmediums_2fmultiplex_5fframes_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[7]
+    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[];
+};
+namespace location {
+namespace nearby {
+namespace mediums {
+class ConnectionRequestFrame;
+struct ConnectionRequestFrameDefaultTypeInternal;
+extern ConnectionRequestFrameDefaultTypeInternal _ConnectionRequestFrame_default_instance_;
+class ConnectionResponseFrame;
+struct ConnectionResponseFrameDefaultTypeInternal;
+extern ConnectionResponseFrameDefaultTypeInternal _ConnectionResponseFrame_default_instance_;
+class DisconnectFrame;
+struct DisconnectFrameDefaultTypeInternal;
+extern DisconnectFrameDefaultTypeInternal _DisconnectFrame_default_instance_;
+class MultiplexControlFrame;
+struct MultiplexControlFrameDefaultTypeInternal;
+extern MultiplexControlFrameDefaultTypeInternal _MultiplexControlFrame_default_instance_;
+class MultiplexDataFrame;
+struct MultiplexDataFrameDefaultTypeInternal;
+extern MultiplexDataFrameDefaultTypeInternal _MultiplexDataFrame_default_instance_;
+class MultiplexFrame;
+struct MultiplexFrameDefaultTypeInternal;
+extern MultiplexFrameDefaultTypeInternal _MultiplexFrame_default_instance_;
+class MultiplexFrameHeader;
+struct MultiplexFrameHeaderDefaultTypeInternal;
+extern MultiplexFrameHeaderDefaultTypeInternal _MultiplexFrameHeader_default_instance_;
+}  // namespace mediums
+}  // namespace nearby
+}  // namespace location
+PROTOBUF_NAMESPACE_OPEN
+template<> ::location::nearby::mediums::ConnectionRequestFrame* Arena::CreateMaybeMessage<::location::nearby::mediums::ConnectionRequestFrame>(Arena*);
+template<> ::location::nearby::mediums::ConnectionResponseFrame* Arena::CreateMaybeMessage<::location::nearby::mediums::ConnectionResponseFrame>(Arena*);
+template<> ::location::nearby::mediums::DisconnectFrame* Arena::CreateMaybeMessage<::location::nearby::mediums::DisconnectFrame>(Arena*);
+template<> ::location::nearby::mediums::MultiplexControlFrame* Arena::CreateMaybeMessage<::location::nearby::mediums::MultiplexControlFrame>(Arena*);
+template<> ::location::nearby::mediums::MultiplexDataFrame* Arena::CreateMaybeMessage<::location::nearby::mediums::MultiplexDataFrame>(Arena*);
+template<> ::location::nearby::mediums::MultiplexFrame* Arena::CreateMaybeMessage<::location::nearby::mediums::MultiplexFrame>(Arena*);
+template<> ::location::nearby::mediums::MultiplexFrameHeader* Arena::CreateMaybeMessage<::location::nearby::mediums::MultiplexFrameHeader>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace location {
+namespace nearby {
+namespace mediums {
+
+enum MultiplexFrame_MultiplexFrameType : int {
+  MultiplexFrame_MultiplexFrameType_UNKNOWN_FRAME_TYPE = 0,
+  MultiplexFrame_MultiplexFrameType_CONTROL_FRAME = 1,
+  MultiplexFrame_MultiplexFrameType_DATA_FRAME = 2
+};
+bool MultiplexFrame_MultiplexFrameType_IsValid(int value);
+constexpr MultiplexFrame_MultiplexFrameType MultiplexFrame_MultiplexFrameType_MultiplexFrameType_MIN = MultiplexFrame_MultiplexFrameType_UNKNOWN_FRAME_TYPE;
+constexpr MultiplexFrame_MultiplexFrameType MultiplexFrame_MultiplexFrameType_MultiplexFrameType_MAX = MultiplexFrame_MultiplexFrameType_DATA_FRAME;
+constexpr int MultiplexFrame_MultiplexFrameType_MultiplexFrameType_ARRAYSIZE = MultiplexFrame_MultiplexFrameType_MultiplexFrameType_MAX + 1;
+
+const std::string& MultiplexFrame_MultiplexFrameType_Name(MultiplexFrame_MultiplexFrameType value);
+template<typename T>
+inline const std::string& MultiplexFrame_MultiplexFrameType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, MultiplexFrame_MultiplexFrameType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function MultiplexFrame_MultiplexFrameType_Name.");
+  return MultiplexFrame_MultiplexFrameType_Name(static_cast<MultiplexFrame_MultiplexFrameType>(enum_t_value));
+}
+bool MultiplexFrame_MultiplexFrameType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MultiplexFrame_MultiplexFrameType* value);
+enum MultiplexControlFrame_MultiplexControlFrameType : int {
+  MultiplexControlFrame_MultiplexControlFrameType_UNKNOWN_CONTROL_FRAME_TYPE = 0,
+  MultiplexControlFrame_MultiplexControlFrameType_CONNECTION_REQUEST = 1,
+  MultiplexControlFrame_MultiplexControlFrameType_CONNECTION_RESPONSE = 2,
+  MultiplexControlFrame_MultiplexControlFrameType_DISCONNECTION = 3
+};
+bool MultiplexControlFrame_MultiplexControlFrameType_IsValid(int value);
+constexpr MultiplexControlFrame_MultiplexControlFrameType MultiplexControlFrame_MultiplexControlFrameType_MultiplexControlFrameType_MIN = MultiplexControlFrame_MultiplexControlFrameType_UNKNOWN_CONTROL_FRAME_TYPE;
+constexpr MultiplexControlFrame_MultiplexControlFrameType MultiplexControlFrame_MultiplexControlFrameType_MultiplexControlFrameType_MAX = MultiplexControlFrame_MultiplexControlFrameType_DISCONNECTION;
+constexpr int MultiplexControlFrame_MultiplexControlFrameType_MultiplexControlFrameType_ARRAYSIZE = MultiplexControlFrame_MultiplexControlFrameType_MultiplexControlFrameType_MAX + 1;
+
+const std::string& MultiplexControlFrame_MultiplexControlFrameType_Name(MultiplexControlFrame_MultiplexControlFrameType value);
+template<typename T>
+inline const std::string& MultiplexControlFrame_MultiplexControlFrameType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, MultiplexControlFrame_MultiplexControlFrameType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function MultiplexControlFrame_MultiplexControlFrameType_Name.");
+  return MultiplexControlFrame_MultiplexControlFrameType_Name(static_cast<MultiplexControlFrame_MultiplexControlFrameType>(enum_t_value));
+}
+bool MultiplexControlFrame_MultiplexControlFrameType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MultiplexControlFrame_MultiplexControlFrameType* value);
+enum ConnectionResponseFrame_ConnectionResponseCode : int {
+  ConnectionResponseFrame_ConnectionResponseCode_UNKNOWN_RESPONSE_CODE = 0,
+  ConnectionResponseFrame_ConnectionResponseCode_CONNECTION_ACCEPTED = 1,
+  ConnectionResponseFrame_ConnectionResponseCode_NOT_LISTENING = 2
+};
+bool ConnectionResponseFrame_ConnectionResponseCode_IsValid(int value);
+constexpr ConnectionResponseFrame_ConnectionResponseCode ConnectionResponseFrame_ConnectionResponseCode_ConnectionResponseCode_MIN = ConnectionResponseFrame_ConnectionResponseCode_UNKNOWN_RESPONSE_CODE;
+constexpr ConnectionResponseFrame_ConnectionResponseCode ConnectionResponseFrame_ConnectionResponseCode_ConnectionResponseCode_MAX = ConnectionResponseFrame_ConnectionResponseCode_NOT_LISTENING;
+constexpr int ConnectionResponseFrame_ConnectionResponseCode_ConnectionResponseCode_ARRAYSIZE = ConnectionResponseFrame_ConnectionResponseCode_ConnectionResponseCode_MAX + 1;
+
+const std::string& ConnectionResponseFrame_ConnectionResponseCode_Name(ConnectionResponseFrame_ConnectionResponseCode value);
+template<typename T>
+inline const std::string& ConnectionResponseFrame_ConnectionResponseCode_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ConnectionResponseFrame_ConnectionResponseCode>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ConnectionResponseFrame_ConnectionResponseCode_Name.");
+  return ConnectionResponseFrame_ConnectionResponseCode_Name(static_cast<ConnectionResponseFrame_ConnectionResponseCode>(enum_t_value));
+}
+bool ConnectionResponseFrame_ConnectionResponseCode_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConnectionResponseFrame_ConnectionResponseCode* value);
+// ===================================================================
+
+class MultiplexFrame final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.mediums.MultiplexFrame) */ {
+ public:
+  inline MultiplexFrame() : MultiplexFrame(nullptr) {}
+  ~MultiplexFrame() override;
+  explicit constexpr MultiplexFrame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  MultiplexFrame(const MultiplexFrame& from);
+  MultiplexFrame(MultiplexFrame&& from) noexcept
+    : MultiplexFrame() {
+    *this = ::std::move(from);
+  }
+
+  inline MultiplexFrame& operator=(const MultiplexFrame& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline MultiplexFrame& operator=(MultiplexFrame&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const MultiplexFrame& default_instance() {
+    return *internal_default_instance();
+  }
+  enum FrameCase {
+    kControlFrame = 3,
+    kDataFrame = 4,
+    FRAME_NOT_SET = 0,
+  };
+
+  static inline const MultiplexFrame* internal_default_instance() {
+    return reinterpret_cast<const MultiplexFrame*>(
+               &_MultiplexFrame_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(MultiplexFrame& a, MultiplexFrame& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(MultiplexFrame* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(MultiplexFrame* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  MultiplexFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<MultiplexFrame>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const MultiplexFrame& from);
+  void MergeFrom(const MultiplexFrame& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(MultiplexFrame* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "location.nearby.mediums.MultiplexFrame";
+  }
+  protected:
+  explicit MultiplexFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef MultiplexFrame_MultiplexFrameType MultiplexFrameType;
+  static constexpr MultiplexFrameType UNKNOWN_FRAME_TYPE =
+    MultiplexFrame_MultiplexFrameType_UNKNOWN_FRAME_TYPE;
+  static constexpr MultiplexFrameType CONTROL_FRAME =
+    MultiplexFrame_MultiplexFrameType_CONTROL_FRAME;
+  static constexpr MultiplexFrameType DATA_FRAME =
+    MultiplexFrame_MultiplexFrameType_DATA_FRAME;
+  static inline bool MultiplexFrameType_IsValid(int value) {
+    return MultiplexFrame_MultiplexFrameType_IsValid(value);
+  }
+  static constexpr MultiplexFrameType MultiplexFrameType_MIN =
+    MultiplexFrame_MultiplexFrameType_MultiplexFrameType_MIN;
+  static constexpr MultiplexFrameType MultiplexFrameType_MAX =
+    MultiplexFrame_MultiplexFrameType_MultiplexFrameType_MAX;
+  static constexpr int MultiplexFrameType_ARRAYSIZE =
+    MultiplexFrame_MultiplexFrameType_MultiplexFrameType_ARRAYSIZE;
+  template<typename T>
+  static inline const std::string& MultiplexFrameType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, MultiplexFrameType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function MultiplexFrameType_Name.");
+    return MultiplexFrame_MultiplexFrameType_Name(enum_t_value);
+  }
+  static inline bool MultiplexFrameType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      MultiplexFrameType* value) {
+    return MultiplexFrame_MultiplexFrameType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kHeaderFieldNumber = 1,
+    kFrameTypeFieldNumber = 2,
+    kControlFrameFieldNumber = 3,
+    kDataFrameFieldNumber = 4,
+  };
+  // optional .location.nearby.mediums.MultiplexFrameHeader header = 1;
+  bool has_header() const;
+  private:
+  bool _internal_has_header() const;
+  public:
+  void clear_header();
+  const ::location::nearby::mediums::MultiplexFrameHeader& header() const;
+  PROTOBUF_NODISCARD ::location::nearby::mediums::MultiplexFrameHeader* release_header();
+  ::location::nearby::mediums::MultiplexFrameHeader* mutable_header();
+  void set_allocated_header(::location::nearby::mediums::MultiplexFrameHeader* header);
+  private:
+  const ::location::nearby::mediums::MultiplexFrameHeader& _internal_header() const;
+  ::location::nearby::mediums::MultiplexFrameHeader* _internal_mutable_header();
+  public:
+  void unsafe_arena_set_allocated_header(
+      ::location::nearby::mediums::MultiplexFrameHeader* header);
+  ::location::nearby::mediums::MultiplexFrameHeader* unsafe_arena_release_header();
+
+  // optional .location.nearby.mediums.MultiplexFrame.MultiplexFrameType frame_type = 2;
+  bool has_frame_type() const;
+  private:
+  bool _internal_has_frame_type() const;
+  public:
+  void clear_frame_type();
+  ::location::nearby::mediums::MultiplexFrame_MultiplexFrameType frame_type() const;
+  void set_frame_type(::location::nearby::mediums::MultiplexFrame_MultiplexFrameType value);
+  private:
+  ::location::nearby::mediums::MultiplexFrame_MultiplexFrameType _internal_frame_type() const;
+  void _internal_set_frame_type(::location::nearby::mediums::MultiplexFrame_MultiplexFrameType value);
+  public:
+
+  // .location.nearby.mediums.MultiplexControlFrame control_frame = 3;
+  bool has_control_frame() const;
+  private:
+  bool _internal_has_control_frame() const;
+  public:
+  void clear_control_frame();
+  const ::location::nearby::mediums::MultiplexControlFrame& control_frame() const;
+  PROTOBUF_NODISCARD ::location::nearby::mediums::MultiplexControlFrame* release_control_frame();
+  ::location::nearby::mediums::MultiplexControlFrame* mutable_control_frame();
+  void set_allocated_control_frame(::location::nearby::mediums::MultiplexControlFrame* control_frame);
+  private:
+  const ::location::nearby::mediums::MultiplexControlFrame& _internal_control_frame() const;
+  ::location::nearby::mediums::MultiplexControlFrame* _internal_mutable_control_frame();
+  public:
+  void unsafe_arena_set_allocated_control_frame(
+      ::location::nearby::mediums::MultiplexControlFrame* control_frame);
+  ::location::nearby::mediums::MultiplexControlFrame* unsafe_arena_release_control_frame();
+
+  // .location.nearby.mediums.MultiplexDataFrame data_frame = 4;
+  bool has_data_frame() const;
+  private:
+  bool _internal_has_data_frame() const;
+  public:
+  void clear_data_frame();
+  const ::location::nearby::mediums::MultiplexDataFrame& data_frame() const;
+  PROTOBUF_NODISCARD ::location::nearby::mediums::MultiplexDataFrame* release_data_frame();
+  ::location::nearby::mediums::MultiplexDataFrame* mutable_data_frame();
+  void set_allocated_data_frame(::location::nearby::mediums::MultiplexDataFrame* data_frame);
+  private:
+  const ::location::nearby::mediums::MultiplexDataFrame& _internal_data_frame() const;
+  ::location::nearby::mediums::MultiplexDataFrame* _internal_mutable_data_frame();
+  public:
+  void unsafe_arena_set_allocated_data_frame(
+      ::location::nearby::mediums::MultiplexDataFrame* data_frame);
+  ::location::nearby::mediums::MultiplexDataFrame* unsafe_arena_release_data_frame();
+
+  void clear_Frame();
+  FrameCase Frame_case() const;
+  // @@protoc_insertion_point(class_scope:location.nearby.mediums.MultiplexFrame)
+ private:
+  class _Internal;
+  void set_has_control_frame();
+  void set_has_data_frame();
+
+  inline bool has_Frame() const;
+  inline void clear_has_Frame();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::location::nearby::mediums::MultiplexFrameHeader* header_;
+  int frame_type_;
+  union FrameUnion {
+    constexpr FrameUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::location::nearby::mediums::MultiplexControlFrame* control_frame_;
+    ::location::nearby::mediums::MultiplexDataFrame* data_frame_;
+  } Frame_;
+  uint32_t _oneof_case_[1];
+
+  friend struct ::TableStruct_proto_2fmediums_2fmultiplex_5fframes_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MultiplexFrameHeader final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.mediums.MultiplexFrameHeader) */ {
+ public:
+  inline MultiplexFrameHeader() : MultiplexFrameHeader(nullptr) {}
+  ~MultiplexFrameHeader() override;
+  explicit constexpr MultiplexFrameHeader(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  MultiplexFrameHeader(const MultiplexFrameHeader& from);
+  MultiplexFrameHeader(MultiplexFrameHeader&& from) noexcept
+    : MultiplexFrameHeader() {
+    *this = ::std::move(from);
+  }
+
+  inline MultiplexFrameHeader& operator=(const MultiplexFrameHeader& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline MultiplexFrameHeader& operator=(MultiplexFrameHeader&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const MultiplexFrameHeader& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const MultiplexFrameHeader* internal_default_instance() {
+    return reinterpret_cast<const MultiplexFrameHeader*>(
+               &_MultiplexFrameHeader_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(MultiplexFrameHeader& a, MultiplexFrameHeader& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(MultiplexFrameHeader* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(MultiplexFrameHeader* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  MultiplexFrameHeader* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<MultiplexFrameHeader>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const MultiplexFrameHeader& from);
+  void MergeFrom(const MultiplexFrameHeader& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(MultiplexFrameHeader* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "location.nearby.mediums.MultiplexFrameHeader";
+  }
+  protected:
+  explicit MultiplexFrameHeader(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSaltedServiceIdHashFieldNumber = 1,
+    kServiceIdHashSaltFieldNumber = 2,
+  };
+  // optional bytes salted_service_id_hash = 1;
+  bool has_salted_service_id_hash() const;
+  private:
+  bool _internal_has_salted_service_id_hash() const;
+  public:
+  void clear_salted_service_id_hash();
+  const std::string& salted_service_id_hash() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_salted_service_id_hash(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_salted_service_id_hash();
+  PROTOBUF_NODISCARD std::string* release_salted_service_id_hash();
+  void set_allocated_salted_service_id_hash(std::string* salted_service_id_hash);
+  private:
+  const std::string& _internal_salted_service_id_hash() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_salted_service_id_hash(const std::string& value);
+  std::string* _internal_mutable_salted_service_id_hash();
+  public:
+
+  // optional string service_id_hash_salt = 2;
+  bool has_service_id_hash_salt() const;
+  private:
+  bool _internal_has_service_id_hash_salt() const;
+  public:
+  void clear_service_id_hash_salt();
+  const std::string& service_id_hash_salt() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_service_id_hash_salt(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_service_id_hash_salt();
+  PROTOBUF_NODISCARD std::string* release_service_id_hash_salt();
+  void set_allocated_service_id_hash_salt(std::string* service_id_hash_salt);
+  private:
+  const std::string& _internal_service_id_hash_salt() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_service_id_hash_salt(const std::string& value);
+  std::string* _internal_mutable_service_id_hash_salt();
+  public:
+
+  // @@protoc_insertion_point(class_scope:location.nearby.mediums.MultiplexFrameHeader)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr salted_service_id_hash_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr service_id_hash_salt_;
+  friend struct ::TableStruct_proto_2fmediums_2fmultiplex_5fframes_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MultiplexControlFrame final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.mediums.MultiplexControlFrame) */ {
+ public:
+  inline MultiplexControlFrame() : MultiplexControlFrame(nullptr) {}
+  ~MultiplexControlFrame() override;
+  explicit constexpr MultiplexControlFrame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  MultiplexControlFrame(const MultiplexControlFrame& from);
+  MultiplexControlFrame(MultiplexControlFrame&& from) noexcept
+    : MultiplexControlFrame() {
+    *this = ::std::move(from);
+  }
+
+  inline MultiplexControlFrame& operator=(const MultiplexControlFrame& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline MultiplexControlFrame& operator=(MultiplexControlFrame&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const MultiplexControlFrame& default_instance() {
+    return *internal_default_instance();
+  }
+  enum FrameCase {
+    kConnectionRequestFrame = 2,
+    kConnectionResponseFrame = 3,
+    kDisconnectFrame = 4,
+    FRAME_NOT_SET = 0,
+  };
+
+  static inline const MultiplexControlFrame* internal_default_instance() {
+    return reinterpret_cast<const MultiplexControlFrame*>(
+               &_MultiplexControlFrame_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(MultiplexControlFrame& a, MultiplexControlFrame& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(MultiplexControlFrame* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(MultiplexControlFrame* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  MultiplexControlFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<MultiplexControlFrame>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const MultiplexControlFrame& from);
+  void MergeFrom(const MultiplexControlFrame& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(MultiplexControlFrame* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "location.nearby.mediums.MultiplexControlFrame";
+  }
+  protected:
+  explicit MultiplexControlFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef MultiplexControlFrame_MultiplexControlFrameType MultiplexControlFrameType;
+  static constexpr MultiplexControlFrameType UNKNOWN_CONTROL_FRAME_TYPE =
+    MultiplexControlFrame_MultiplexControlFrameType_UNKNOWN_CONTROL_FRAME_TYPE;
+  static constexpr MultiplexControlFrameType CONNECTION_REQUEST =
+    MultiplexControlFrame_MultiplexControlFrameType_CONNECTION_REQUEST;
+  static constexpr MultiplexControlFrameType CONNECTION_RESPONSE =
+    MultiplexControlFrame_MultiplexControlFrameType_CONNECTION_RESPONSE;
+  static constexpr MultiplexControlFrameType DISCONNECTION =
+    MultiplexControlFrame_MultiplexControlFrameType_DISCONNECTION;
+  static inline bool MultiplexControlFrameType_IsValid(int value) {
+    return MultiplexControlFrame_MultiplexControlFrameType_IsValid(value);
+  }
+  static constexpr MultiplexControlFrameType MultiplexControlFrameType_MIN =
+    MultiplexControlFrame_MultiplexControlFrameType_MultiplexControlFrameType_MIN;
+  static constexpr MultiplexControlFrameType MultiplexControlFrameType_MAX =
+    MultiplexControlFrame_MultiplexControlFrameType_MultiplexControlFrameType_MAX;
+  static constexpr int MultiplexControlFrameType_ARRAYSIZE =
+    MultiplexControlFrame_MultiplexControlFrameType_MultiplexControlFrameType_ARRAYSIZE;
+  template<typename T>
+  static inline const std::string& MultiplexControlFrameType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, MultiplexControlFrameType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function MultiplexControlFrameType_Name.");
+    return MultiplexControlFrame_MultiplexControlFrameType_Name(enum_t_value);
+  }
+  static inline bool MultiplexControlFrameType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      MultiplexControlFrameType* value) {
+    return MultiplexControlFrame_MultiplexControlFrameType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kControlFrameTypeFieldNumber = 1,
+    kConnectionRequestFrameFieldNumber = 2,
+    kConnectionResponseFrameFieldNumber = 3,
+    kDisconnectFrameFieldNumber = 4,
+  };
+  // optional .location.nearby.mediums.MultiplexControlFrame.MultiplexControlFrameType control_frame_type = 1;
+  bool has_control_frame_type() const;
+  private:
+  bool _internal_has_control_frame_type() const;
+  public:
+  void clear_control_frame_type();
+  ::location::nearby::mediums::MultiplexControlFrame_MultiplexControlFrameType control_frame_type() const;
+  void set_control_frame_type(::location::nearby::mediums::MultiplexControlFrame_MultiplexControlFrameType value);
+  private:
+  ::location::nearby::mediums::MultiplexControlFrame_MultiplexControlFrameType _internal_control_frame_type() const;
+  void _internal_set_control_frame_type(::location::nearby::mediums::MultiplexControlFrame_MultiplexControlFrameType value);
+  public:
+
+  // .location.nearby.mediums.ConnectionRequestFrame connection_request_frame = 2;
+  bool has_connection_request_frame() const;
+  private:
+  bool _internal_has_connection_request_frame() const;
+  public:
+  void clear_connection_request_frame();
+  const ::location::nearby::mediums::ConnectionRequestFrame& connection_request_frame() const;
+  PROTOBUF_NODISCARD ::location::nearby::mediums::ConnectionRequestFrame* release_connection_request_frame();
+  ::location::nearby::mediums::ConnectionRequestFrame* mutable_connection_request_frame();
+  void set_allocated_connection_request_frame(::location::nearby::mediums::ConnectionRequestFrame* connection_request_frame);
+  private:
+  const ::location::nearby::mediums::ConnectionRequestFrame& _internal_connection_request_frame() const;
+  ::location::nearby::mediums::ConnectionRequestFrame* _internal_mutable_connection_request_frame();
+  public:
+  void unsafe_arena_set_allocated_connection_request_frame(
+      ::location::nearby::mediums::ConnectionRequestFrame* connection_request_frame);
+  ::location::nearby::mediums::ConnectionRequestFrame* unsafe_arena_release_connection_request_frame();
+
+  // .location.nearby.mediums.ConnectionResponseFrame connection_response_frame = 3;
+  bool has_connection_response_frame() const;
+  private:
+  bool _internal_has_connection_response_frame() const;
+  public:
+  void clear_connection_response_frame();
+  const ::location::nearby::mediums::ConnectionResponseFrame& connection_response_frame() const;
+  PROTOBUF_NODISCARD ::location::nearby::mediums::ConnectionResponseFrame* release_connection_response_frame();
+  ::location::nearby::mediums::ConnectionResponseFrame* mutable_connection_response_frame();
+  void set_allocated_connection_response_frame(::location::nearby::mediums::ConnectionResponseFrame* connection_response_frame);
+  private:
+  const ::location::nearby::mediums::ConnectionResponseFrame& _internal_connection_response_frame() const;
+  ::location::nearby::mediums::ConnectionResponseFrame* _internal_mutable_connection_response_frame();
+  public:
+  void unsafe_arena_set_allocated_connection_response_frame(
+      ::location::nearby::mediums::ConnectionResponseFrame* connection_response_frame);
+  ::location::nearby::mediums::ConnectionResponseFrame* unsafe_arena_release_connection_response_frame();
+
+  // .location.nearby.mediums.DisconnectFrame disconnect_frame = 4;
+  bool has_disconnect_frame() const;
+  private:
+  bool _internal_has_disconnect_frame() const;
+  public:
+  void clear_disconnect_frame();
+  const ::location::nearby::mediums::DisconnectFrame& disconnect_frame() const;
+  PROTOBUF_NODISCARD ::location::nearby::mediums::DisconnectFrame* release_disconnect_frame();
+  ::location::nearby::mediums::DisconnectFrame* mutable_disconnect_frame();
+  void set_allocated_disconnect_frame(::location::nearby::mediums::DisconnectFrame* disconnect_frame);
+  private:
+  const ::location::nearby::mediums::DisconnectFrame& _internal_disconnect_frame() const;
+  ::location::nearby::mediums::DisconnectFrame* _internal_mutable_disconnect_frame();
+  public:
+  void unsafe_arena_set_allocated_disconnect_frame(
+      ::location::nearby::mediums::DisconnectFrame* disconnect_frame);
+  ::location::nearby::mediums::DisconnectFrame* unsafe_arena_release_disconnect_frame();
+
+  void clear_Frame();
+  FrameCase Frame_case() const;
+  // @@protoc_insertion_point(class_scope:location.nearby.mediums.MultiplexControlFrame)
+ private:
+  class _Internal;
+  void set_has_connection_request_frame();
+  void set_has_connection_response_frame();
+  void set_has_disconnect_frame();
+
+  inline bool has_Frame() const;
+  inline void clear_has_Frame();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  int control_frame_type_;
+  union FrameUnion {
+    constexpr FrameUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::location::nearby::mediums::ConnectionRequestFrame* connection_request_frame_;
+    ::location::nearby::mediums::ConnectionResponseFrame* connection_response_frame_;
+    ::location::nearby::mediums::DisconnectFrame* disconnect_frame_;
+  } Frame_;
+  uint32_t _oneof_case_[1];
+
+  friend struct ::TableStruct_proto_2fmediums_2fmultiplex_5fframes_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ConnectionRequestFrame final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.mediums.ConnectionRequestFrame) */ {
+ public:
+  inline ConnectionRequestFrame() : ConnectionRequestFrame(nullptr) {}
+  ~ConnectionRequestFrame() override;
+  explicit constexpr ConnectionRequestFrame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ConnectionRequestFrame(const ConnectionRequestFrame& from);
+  ConnectionRequestFrame(ConnectionRequestFrame&& from) noexcept
+    : ConnectionRequestFrame() {
+    *this = ::std::move(from);
+  }
+
+  inline ConnectionRequestFrame& operator=(const ConnectionRequestFrame& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ConnectionRequestFrame& operator=(ConnectionRequestFrame&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ConnectionRequestFrame& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ConnectionRequestFrame* internal_default_instance() {
+    return reinterpret_cast<const ConnectionRequestFrame*>(
+               &_ConnectionRequestFrame_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(ConnectionRequestFrame& a, ConnectionRequestFrame& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ConnectionRequestFrame* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ConnectionRequestFrame* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ConnectionRequestFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ConnectionRequestFrame>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ConnectionRequestFrame& from);
+  void MergeFrom(const ConnectionRequestFrame& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ConnectionRequestFrame* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "location.nearby.mediums.ConnectionRequestFrame";
+  }
+  protected:
+  explicit ConnectionRequestFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // @@protoc_insertion_point(class_scope:location.nearby.mediums.ConnectionRequestFrame)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_proto_2fmediums_2fmultiplex_5fframes_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ConnectionResponseFrame final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.mediums.ConnectionResponseFrame) */ {
+ public:
+  inline ConnectionResponseFrame() : ConnectionResponseFrame(nullptr) {}
+  ~ConnectionResponseFrame() override;
+  explicit constexpr ConnectionResponseFrame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ConnectionResponseFrame(const ConnectionResponseFrame& from);
+  ConnectionResponseFrame(ConnectionResponseFrame&& from) noexcept
+    : ConnectionResponseFrame() {
+    *this = ::std::move(from);
+  }
+
+  inline ConnectionResponseFrame& operator=(const ConnectionResponseFrame& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ConnectionResponseFrame& operator=(ConnectionResponseFrame&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ConnectionResponseFrame& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ConnectionResponseFrame* internal_default_instance() {
+    return reinterpret_cast<const ConnectionResponseFrame*>(
+               &_ConnectionResponseFrame_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(ConnectionResponseFrame& a, ConnectionResponseFrame& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ConnectionResponseFrame* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ConnectionResponseFrame* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ConnectionResponseFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ConnectionResponseFrame>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ConnectionResponseFrame& from);
+  void MergeFrom(const ConnectionResponseFrame& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ConnectionResponseFrame* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "location.nearby.mediums.ConnectionResponseFrame";
+  }
+  protected:
+  explicit ConnectionResponseFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ConnectionResponseFrame_ConnectionResponseCode ConnectionResponseCode;
+  static constexpr ConnectionResponseCode UNKNOWN_RESPONSE_CODE =
+    ConnectionResponseFrame_ConnectionResponseCode_UNKNOWN_RESPONSE_CODE;
+  static constexpr ConnectionResponseCode CONNECTION_ACCEPTED =
+    ConnectionResponseFrame_ConnectionResponseCode_CONNECTION_ACCEPTED;
+  static constexpr ConnectionResponseCode NOT_LISTENING =
+    ConnectionResponseFrame_ConnectionResponseCode_NOT_LISTENING;
+  static inline bool ConnectionResponseCode_IsValid(int value) {
+    return ConnectionResponseFrame_ConnectionResponseCode_IsValid(value);
+  }
+  static constexpr ConnectionResponseCode ConnectionResponseCode_MIN =
+    ConnectionResponseFrame_ConnectionResponseCode_ConnectionResponseCode_MIN;
+  static constexpr ConnectionResponseCode ConnectionResponseCode_MAX =
+    ConnectionResponseFrame_ConnectionResponseCode_ConnectionResponseCode_MAX;
+  static constexpr int ConnectionResponseCode_ARRAYSIZE =
+    ConnectionResponseFrame_ConnectionResponseCode_ConnectionResponseCode_ARRAYSIZE;
+  template<typename T>
+  static inline const std::string& ConnectionResponseCode_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ConnectionResponseCode>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ConnectionResponseCode_Name.");
+    return ConnectionResponseFrame_ConnectionResponseCode_Name(enum_t_value);
+  }
+  static inline bool ConnectionResponseCode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ConnectionResponseCode* value) {
+    return ConnectionResponseFrame_ConnectionResponseCode_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kConnectionResponseCodeFieldNumber = 1,
+  };
+  // optional .location.nearby.mediums.ConnectionResponseFrame.ConnectionResponseCode connection_response_code = 1;
+  bool has_connection_response_code() const;
+  private:
+  bool _internal_has_connection_response_code() const;
+  public:
+  void clear_connection_response_code();
+  ::location::nearby::mediums::ConnectionResponseFrame_ConnectionResponseCode connection_response_code() const;
+  void set_connection_response_code(::location::nearby::mediums::ConnectionResponseFrame_ConnectionResponseCode value);
+  private:
+  ::location::nearby::mediums::ConnectionResponseFrame_ConnectionResponseCode _internal_connection_response_code() const;
+  void _internal_set_connection_response_code(::location::nearby::mediums::ConnectionResponseFrame_ConnectionResponseCode value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:location.nearby.mediums.ConnectionResponseFrame)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  int connection_response_code_;
+  friend struct ::TableStruct_proto_2fmediums_2fmultiplex_5fframes_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DisconnectFrame final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.mediums.DisconnectFrame) */ {
+ public:
+  inline DisconnectFrame() : DisconnectFrame(nullptr) {}
+  ~DisconnectFrame() override;
+  explicit constexpr DisconnectFrame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DisconnectFrame(const DisconnectFrame& from);
+  DisconnectFrame(DisconnectFrame&& from) noexcept
+    : DisconnectFrame() {
+    *this = ::std::move(from);
+  }
+
+  inline DisconnectFrame& operator=(const DisconnectFrame& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DisconnectFrame& operator=(DisconnectFrame&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const DisconnectFrame& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DisconnectFrame* internal_default_instance() {
+    return reinterpret_cast<const DisconnectFrame*>(
+               &_DisconnectFrame_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(DisconnectFrame& a, DisconnectFrame& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DisconnectFrame* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DisconnectFrame* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  DisconnectFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<DisconnectFrame>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const DisconnectFrame& from);
+  void MergeFrom(const DisconnectFrame& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(DisconnectFrame* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "location.nearby.mediums.DisconnectFrame";
+  }
+  protected:
+  explicit DisconnectFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // @@protoc_insertion_point(class_scope:location.nearby.mediums.DisconnectFrame)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_proto_2fmediums_2fmultiplex_5fframes_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MultiplexDataFrame final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.mediums.MultiplexDataFrame) */ {
+ public:
+  inline MultiplexDataFrame() : MultiplexDataFrame(nullptr) {}
+  ~MultiplexDataFrame() override;
+  explicit constexpr MultiplexDataFrame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  MultiplexDataFrame(const MultiplexDataFrame& from);
+  MultiplexDataFrame(MultiplexDataFrame&& from) noexcept
+    : MultiplexDataFrame() {
+    *this = ::std::move(from);
+  }
+
+  inline MultiplexDataFrame& operator=(const MultiplexDataFrame& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline MultiplexDataFrame& operator=(MultiplexDataFrame&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const MultiplexDataFrame& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const MultiplexDataFrame* internal_default_instance() {
+    return reinterpret_cast<const MultiplexDataFrame*>(
+               &_MultiplexDataFrame_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  friend void swap(MultiplexDataFrame& a, MultiplexDataFrame& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(MultiplexDataFrame* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(MultiplexDataFrame* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  MultiplexDataFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<MultiplexDataFrame>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const MultiplexDataFrame& from);
+  void MergeFrom(const MultiplexDataFrame& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(MultiplexDataFrame* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "location.nearby.mediums.MultiplexDataFrame";
+  }
+  protected:
+  explicit MultiplexDataFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDataFieldNumber = 1,
+  };
+  // optional bytes data = 1;
+  bool has_data() const;
+  private:
+  bool _internal_has_data() const;
+  public:
+  void clear_data();
+  const std::string& data() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_data(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_data();
+  PROTOBUF_NODISCARD std::string* release_data();
+  void set_allocated_data(std::string* data);
+  private:
+  const std::string& _internal_data() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value);
+  std::string* _internal_mutable_data();
+  public:
+
+  // @@protoc_insertion_point(class_scope:location.nearby.mediums.MultiplexDataFrame)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
+  friend struct ::TableStruct_proto_2fmediums_2fmultiplex_5fframes_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// MultiplexFrame
+
+// optional .location.nearby.mediums.MultiplexFrameHeader header = 1;
+inline bool MultiplexFrame::_internal_has_header() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || header_ != nullptr);
+  return value;
+}
+inline bool MultiplexFrame::has_header() const {
+  return _internal_has_header();
+}
+inline void MultiplexFrame::clear_header() {
+  if (header_ != nullptr) header_->Clear();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const ::location::nearby::mediums::MultiplexFrameHeader& MultiplexFrame::_internal_header() const {
+  const ::location::nearby::mediums::MultiplexFrameHeader* p = header_;
+  return p != nullptr ? *p : reinterpret_cast<const ::location::nearby::mediums::MultiplexFrameHeader&>(
+      ::location::nearby::mediums::_MultiplexFrameHeader_default_instance_);
+}
+inline const ::location::nearby::mediums::MultiplexFrameHeader& MultiplexFrame::header() const {
+  // @@protoc_insertion_point(field_get:location.nearby.mediums.MultiplexFrame.header)
+  return _internal_header();
+}
+inline void MultiplexFrame::unsafe_arena_set_allocated_header(
+    ::location::nearby::mediums::MultiplexFrameHeader* header) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(header_);
+  }
+  header_ = header;
+  if (header) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.mediums.MultiplexFrame.header)
+}
+inline ::location::nearby::mediums::MultiplexFrameHeader* MultiplexFrame::release_header() {
+  _has_bits_[0] &= ~0x00000001u;
+  ::location::nearby::mediums::MultiplexFrameHeader* temp = header_;
+  header_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::location::nearby::mediums::MultiplexFrameHeader* MultiplexFrame::unsafe_arena_release_header() {
+  // @@protoc_insertion_point(field_release:location.nearby.mediums.MultiplexFrame.header)
+  _has_bits_[0] &= ~0x00000001u;
+  ::location::nearby::mediums::MultiplexFrameHeader* temp = header_;
+  header_ = nullptr;
+  return temp;
+}
+inline ::location::nearby::mediums::MultiplexFrameHeader* MultiplexFrame::_internal_mutable_header() {
+  _has_bits_[0] |= 0x00000001u;
+  if (header_ == nullptr) {
+    auto* p = CreateMaybeMessage<::location::nearby::mediums::MultiplexFrameHeader>(GetArenaForAllocation());
+    header_ = p;
+  }
+  return header_;
+}
+inline ::location::nearby::mediums::MultiplexFrameHeader* MultiplexFrame::mutable_header() {
+  ::location::nearby::mediums::MultiplexFrameHeader* _msg = _internal_mutable_header();
+  // @@protoc_insertion_point(field_mutable:location.nearby.mediums.MultiplexFrame.header)
+  return _msg;
+}
+inline void MultiplexFrame::set_allocated_header(::location::nearby::mediums::MultiplexFrameHeader* header) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete header_;
+  }
+  if (header) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::mediums::MultiplexFrameHeader>::GetOwningArena(header);
+    if (message_arena != submessage_arena) {
+      header = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, header, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  header_ = header;
+  // @@protoc_insertion_point(field_set_allocated:location.nearby.mediums.MultiplexFrame.header)
+}
+
+// optional .location.nearby.mediums.MultiplexFrame.MultiplexFrameType frame_type = 2;
+inline bool MultiplexFrame::_internal_has_frame_type() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool MultiplexFrame::has_frame_type() const {
+  return _internal_has_frame_type();
+}
+inline void MultiplexFrame::clear_frame_type() {
+  frame_type_ = 0;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::location::nearby::mediums::MultiplexFrame_MultiplexFrameType MultiplexFrame::_internal_frame_type() const {
+  return static_cast< ::location::nearby::mediums::MultiplexFrame_MultiplexFrameType >(frame_type_);
+}
+inline ::location::nearby::mediums::MultiplexFrame_MultiplexFrameType MultiplexFrame::frame_type() const {
+  // @@protoc_insertion_point(field_get:location.nearby.mediums.MultiplexFrame.frame_type)
+  return _internal_frame_type();
+}
+inline void MultiplexFrame::_internal_set_frame_type(::location::nearby::mediums::MultiplexFrame_MultiplexFrameType value) {
+  assert(::location::nearby::mediums::MultiplexFrame_MultiplexFrameType_IsValid(value));
+  _has_bits_[0] |= 0x00000002u;
+  frame_type_ = value;
+}
+inline void MultiplexFrame::set_frame_type(::location::nearby::mediums::MultiplexFrame_MultiplexFrameType value) {
+  _internal_set_frame_type(value);
+  // @@protoc_insertion_point(field_set:location.nearby.mediums.MultiplexFrame.frame_type)
+}
+
+// .location.nearby.mediums.MultiplexControlFrame control_frame = 3;
+inline bool MultiplexFrame::_internal_has_control_frame() const {
+  return Frame_case() == kControlFrame;
+}
+inline bool MultiplexFrame::has_control_frame() const {
+  return _internal_has_control_frame();
+}
+inline void MultiplexFrame::set_has_control_frame() {
+  _oneof_case_[0] = kControlFrame;
+}
+inline void MultiplexFrame::clear_control_frame() {
+  if (_internal_has_control_frame()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete Frame_.control_frame_;
+    }
+    clear_has_Frame();
+  }
+}
+inline ::location::nearby::mediums::MultiplexControlFrame* MultiplexFrame::release_control_frame() {
+  // @@protoc_insertion_point(field_release:location.nearby.mediums.MultiplexFrame.control_frame)
+  if (_internal_has_control_frame()) {
+    clear_has_Frame();
+      ::location::nearby::mediums::MultiplexControlFrame* temp = Frame_.control_frame_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    Frame_.control_frame_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::location::nearby::mediums::MultiplexControlFrame& MultiplexFrame::_internal_control_frame() const {
+  return _internal_has_control_frame()
+      ? *Frame_.control_frame_
+      : reinterpret_cast< ::location::nearby::mediums::MultiplexControlFrame&>(::location::nearby::mediums::_MultiplexControlFrame_default_instance_);
+}
+inline const ::location::nearby::mediums::MultiplexControlFrame& MultiplexFrame::control_frame() const {
+  // @@protoc_insertion_point(field_get:location.nearby.mediums.MultiplexFrame.control_frame)
+  return _internal_control_frame();
+}
+inline ::location::nearby::mediums::MultiplexControlFrame* MultiplexFrame::unsafe_arena_release_control_frame() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:location.nearby.mediums.MultiplexFrame.control_frame)
+  if (_internal_has_control_frame()) {
+    clear_has_Frame();
+    ::location::nearby::mediums::MultiplexControlFrame* temp = Frame_.control_frame_;
+    Frame_.control_frame_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void MultiplexFrame::unsafe_arena_set_allocated_control_frame(::location::nearby::mediums::MultiplexControlFrame* control_frame) {
+  clear_Frame();
+  if (control_frame) {
+    set_has_control_frame();
+    Frame_.control_frame_ = control_frame;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.mediums.MultiplexFrame.control_frame)
+}
+inline ::location::nearby::mediums::MultiplexControlFrame* MultiplexFrame::_internal_mutable_control_frame() {
+  if (!_internal_has_control_frame()) {
+    clear_Frame();
+    set_has_control_frame();
+    Frame_.control_frame_ = CreateMaybeMessage< ::location::nearby::mediums::MultiplexControlFrame >(GetArenaForAllocation());
+  }
+  return Frame_.control_frame_;
+}
+inline ::location::nearby::mediums::MultiplexControlFrame* MultiplexFrame::mutable_control_frame() {
+  ::location::nearby::mediums::MultiplexControlFrame* _msg = _internal_mutable_control_frame();
+  // @@protoc_insertion_point(field_mutable:location.nearby.mediums.MultiplexFrame.control_frame)
+  return _msg;
+}
+
+// .location.nearby.mediums.MultiplexDataFrame data_frame = 4;
+inline bool MultiplexFrame::_internal_has_data_frame() const {
+  return Frame_case() == kDataFrame;
+}
+inline bool MultiplexFrame::has_data_frame() const {
+  return _internal_has_data_frame();
+}
+inline void MultiplexFrame::set_has_data_frame() {
+  _oneof_case_[0] = kDataFrame;
+}
+inline void MultiplexFrame::clear_data_frame() {
+  if (_internal_has_data_frame()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete Frame_.data_frame_;
+    }
+    clear_has_Frame();
+  }
+}
+inline ::location::nearby::mediums::MultiplexDataFrame* MultiplexFrame::release_data_frame() {
+  // @@protoc_insertion_point(field_release:location.nearby.mediums.MultiplexFrame.data_frame)
+  if (_internal_has_data_frame()) {
+    clear_has_Frame();
+      ::location::nearby::mediums::MultiplexDataFrame* temp = Frame_.data_frame_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    Frame_.data_frame_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::location::nearby::mediums::MultiplexDataFrame& MultiplexFrame::_internal_data_frame() const {
+  return _internal_has_data_frame()
+      ? *Frame_.data_frame_
+      : reinterpret_cast< ::location::nearby::mediums::MultiplexDataFrame&>(::location::nearby::mediums::_MultiplexDataFrame_default_instance_);
+}
+inline const ::location::nearby::mediums::MultiplexDataFrame& MultiplexFrame::data_frame() const {
+  // @@protoc_insertion_point(field_get:location.nearby.mediums.MultiplexFrame.data_frame)
+  return _internal_data_frame();
+}
+inline ::location::nearby::mediums::MultiplexDataFrame* MultiplexFrame::unsafe_arena_release_data_frame() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:location.nearby.mediums.MultiplexFrame.data_frame)
+  if (_internal_has_data_frame()) {
+    clear_has_Frame();
+    ::location::nearby::mediums::MultiplexDataFrame* temp = Frame_.data_frame_;
+    Frame_.data_frame_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void MultiplexFrame::unsafe_arena_set_allocated_data_frame(::location::nearby::mediums::MultiplexDataFrame* data_frame) {
+  clear_Frame();
+  if (data_frame) {
+    set_has_data_frame();
+    Frame_.data_frame_ = data_frame;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.mediums.MultiplexFrame.data_frame)
+}
+inline ::location::nearby::mediums::MultiplexDataFrame* MultiplexFrame::_internal_mutable_data_frame() {
+  if (!_internal_has_data_frame()) {
+    clear_Frame();
+    set_has_data_frame();
+    Frame_.data_frame_ = CreateMaybeMessage< ::location::nearby::mediums::MultiplexDataFrame >(GetArenaForAllocation());
+  }
+  return Frame_.data_frame_;
+}
+inline ::location::nearby::mediums::MultiplexDataFrame* MultiplexFrame::mutable_data_frame() {
+  ::location::nearby::mediums::MultiplexDataFrame* _msg = _internal_mutable_data_frame();
+  // @@protoc_insertion_point(field_mutable:location.nearby.mediums.MultiplexFrame.data_frame)
+  return _msg;
+}
+
+inline bool MultiplexFrame::has_Frame() const {
+  return Frame_case() != FRAME_NOT_SET;
+}
+inline void MultiplexFrame::clear_has_Frame() {
+  _oneof_case_[0] = FRAME_NOT_SET;
+}
+inline MultiplexFrame::FrameCase MultiplexFrame::Frame_case() const {
+  return MultiplexFrame::FrameCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// MultiplexFrameHeader
+
+// optional bytes salted_service_id_hash = 1;
+inline bool MultiplexFrameHeader::_internal_has_salted_service_id_hash() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool MultiplexFrameHeader::has_salted_service_id_hash() const {
+  return _internal_has_salted_service_id_hash();
+}
+inline void MultiplexFrameHeader::clear_salted_service_id_hash() {
+  salted_service_id_hash_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& MultiplexFrameHeader::salted_service_id_hash() const {
+  // @@protoc_insertion_point(field_get:location.nearby.mediums.MultiplexFrameHeader.salted_service_id_hash)
+  return _internal_salted_service_id_hash();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MultiplexFrameHeader::set_salted_service_id_hash(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ salted_service_id_hash_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:location.nearby.mediums.MultiplexFrameHeader.salted_service_id_hash)
+}
+inline std::string* MultiplexFrameHeader::mutable_salted_service_id_hash() {
+  std::string* _s = _internal_mutable_salted_service_id_hash();
+  // @@protoc_insertion_point(field_mutable:location.nearby.mediums.MultiplexFrameHeader.salted_service_id_hash)
+  return _s;
+}
+inline const std::string& MultiplexFrameHeader::_internal_salted_service_id_hash() const {
+  return salted_service_id_hash_.Get();
+}
+inline void MultiplexFrameHeader::_internal_set_salted_service_id_hash(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  salted_service_id_hash_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* MultiplexFrameHeader::_internal_mutable_salted_service_id_hash() {
+  _has_bits_[0] |= 0x00000001u;
+  return salted_service_id_hash_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* MultiplexFrameHeader::release_salted_service_id_hash() {
+  // @@protoc_insertion_point(field_release:location.nearby.mediums.MultiplexFrameHeader.salted_service_id_hash)
+  if (!_internal_has_salted_service_id_hash()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  auto* p = salted_service_id_hash_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (salted_service_id_hash_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
+    salted_service_id_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void MultiplexFrameHeader::set_allocated_salted_service_id_hash(std::string* salted_service_id_hash) {
+  if (salted_service_id_hash != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  salted_service_id_hash_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), salted_service_id_hash,
+      GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (salted_service_id_hash_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
+    salted_service_id_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:location.nearby.mediums.MultiplexFrameHeader.salted_service_id_hash)
+}
+
+// optional string service_id_hash_salt = 2;
+inline bool MultiplexFrameHeader::_internal_has_service_id_hash_salt() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool MultiplexFrameHeader::has_service_id_hash_salt() const {
+  return _internal_has_service_id_hash_salt();
+}
+inline void MultiplexFrameHeader::clear_service_id_hash_salt() {
+  service_id_hash_salt_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& MultiplexFrameHeader::service_id_hash_salt() const {
+  // @@protoc_insertion_point(field_get:location.nearby.mediums.MultiplexFrameHeader.service_id_hash_salt)
+  return _internal_service_id_hash_salt();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MultiplexFrameHeader::set_service_id_hash_salt(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ service_id_hash_salt_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:location.nearby.mediums.MultiplexFrameHeader.service_id_hash_salt)
+}
+inline std::string* MultiplexFrameHeader::mutable_service_id_hash_salt() {
+  std::string* _s = _internal_mutable_service_id_hash_salt();
+  // @@protoc_insertion_point(field_mutable:location.nearby.mediums.MultiplexFrameHeader.service_id_hash_salt)
+  return _s;
+}
+inline const std::string& MultiplexFrameHeader::_internal_service_id_hash_salt() const {
+  return service_id_hash_salt_.Get();
+}
+inline void MultiplexFrameHeader::_internal_set_service_id_hash_salt(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  service_id_hash_salt_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* MultiplexFrameHeader::_internal_mutable_service_id_hash_salt() {
+  _has_bits_[0] |= 0x00000002u;
+  return service_id_hash_salt_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* MultiplexFrameHeader::release_service_id_hash_salt() {
+  // @@protoc_insertion_point(field_release:location.nearby.mediums.MultiplexFrameHeader.service_id_hash_salt)
+  if (!_internal_has_service_id_hash_salt()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  auto* p = service_id_hash_salt_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (service_id_hash_salt_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
+    service_id_hash_salt_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void MultiplexFrameHeader::set_allocated_service_id_hash_salt(std::string* service_id_hash_salt) {
+  if (service_id_hash_salt != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  service_id_hash_salt_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), service_id_hash_salt,
+      GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (service_id_hash_salt_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
+    service_id_hash_salt_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:location.nearby.mediums.MultiplexFrameHeader.service_id_hash_salt)
+}
+
+// -------------------------------------------------------------------
+
+// MultiplexControlFrame
+
+// optional .location.nearby.mediums.MultiplexControlFrame.MultiplexControlFrameType control_frame_type = 1;
+inline bool MultiplexControlFrame::_internal_has_control_frame_type() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool MultiplexControlFrame::has_control_frame_type() const {
+  return _internal_has_control_frame_type();
+}
+inline void MultiplexControlFrame::clear_control_frame_type() {
+  control_frame_type_ = 0;
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::location::nearby::mediums::MultiplexControlFrame_MultiplexControlFrameType MultiplexControlFrame::_internal_control_frame_type() const {
+  return static_cast< ::location::nearby::mediums::MultiplexControlFrame_MultiplexControlFrameType >(control_frame_type_);
+}
+inline ::location::nearby::mediums::MultiplexControlFrame_MultiplexControlFrameType MultiplexControlFrame::control_frame_type() const {
+  // @@protoc_insertion_point(field_get:location.nearby.mediums.MultiplexControlFrame.control_frame_type)
+  return _internal_control_frame_type();
+}
+inline void MultiplexControlFrame::_internal_set_control_frame_type(::location::nearby::mediums::MultiplexControlFrame_MultiplexControlFrameType value) {
+  assert(::location::nearby::mediums::MultiplexControlFrame_MultiplexControlFrameType_IsValid(value));
+  _has_bits_[0] |= 0x00000001u;
+  control_frame_type_ = value;
+}
+inline void MultiplexControlFrame::set_control_frame_type(::location::nearby::mediums::MultiplexControlFrame_MultiplexControlFrameType value) {
+  _internal_set_control_frame_type(value);
+  // @@protoc_insertion_point(field_set:location.nearby.mediums.MultiplexControlFrame.control_frame_type)
+}
+
+// .location.nearby.mediums.ConnectionRequestFrame connection_request_frame = 2;
+inline bool MultiplexControlFrame::_internal_has_connection_request_frame() const {
+  return Frame_case() == kConnectionRequestFrame;
+}
+inline bool MultiplexControlFrame::has_connection_request_frame() const {
+  return _internal_has_connection_request_frame();
+}
+inline void MultiplexControlFrame::set_has_connection_request_frame() {
+  _oneof_case_[0] = kConnectionRequestFrame;
+}
+inline void MultiplexControlFrame::clear_connection_request_frame() {
+  if (_internal_has_connection_request_frame()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete Frame_.connection_request_frame_;
+    }
+    clear_has_Frame();
+  }
+}
+inline ::location::nearby::mediums::ConnectionRequestFrame* MultiplexControlFrame::release_connection_request_frame() {
+  // @@protoc_insertion_point(field_release:location.nearby.mediums.MultiplexControlFrame.connection_request_frame)
+  if (_internal_has_connection_request_frame()) {
+    clear_has_Frame();
+      ::location::nearby::mediums::ConnectionRequestFrame* temp = Frame_.connection_request_frame_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    Frame_.connection_request_frame_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::location::nearby::mediums::ConnectionRequestFrame& MultiplexControlFrame::_internal_connection_request_frame() const {
+  return _internal_has_connection_request_frame()
+      ? *Frame_.connection_request_frame_
+      : reinterpret_cast< ::location::nearby::mediums::ConnectionRequestFrame&>(::location::nearby::mediums::_ConnectionRequestFrame_default_instance_);
+}
+inline const ::location::nearby::mediums::ConnectionRequestFrame& MultiplexControlFrame::connection_request_frame() const {
+  // @@protoc_insertion_point(field_get:location.nearby.mediums.MultiplexControlFrame.connection_request_frame)
+  return _internal_connection_request_frame();
+}
+inline ::location::nearby::mediums::ConnectionRequestFrame* MultiplexControlFrame::unsafe_arena_release_connection_request_frame() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:location.nearby.mediums.MultiplexControlFrame.connection_request_frame)
+  if (_internal_has_connection_request_frame()) {
+    clear_has_Frame();
+    ::location::nearby::mediums::ConnectionRequestFrame* temp = Frame_.connection_request_frame_;
+    Frame_.connection_request_frame_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void MultiplexControlFrame::unsafe_arena_set_allocated_connection_request_frame(::location::nearby::mediums::ConnectionRequestFrame* connection_request_frame) {
+  clear_Frame();
+  if (connection_request_frame) {
+    set_has_connection_request_frame();
+    Frame_.connection_request_frame_ = connection_request_frame;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.mediums.MultiplexControlFrame.connection_request_frame)
+}
+inline ::location::nearby::mediums::ConnectionRequestFrame* MultiplexControlFrame::_internal_mutable_connection_request_frame() {
+  if (!_internal_has_connection_request_frame()) {
+    clear_Frame();
+    set_has_connection_request_frame();
+    Frame_.connection_request_frame_ = CreateMaybeMessage< ::location::nearby::mediums::ConnectionRequestFrame >(GetArenaForAllocation());
+  }
+  return Frame_.connection_request_frame_;
+}
+inline ::location::nearby::mediums::ConnectionRequestFrame* MultiplexControlFrame::mutable_connection_request_frame() {
+  ::location::nearby::mediums::ConnectionRequestFrame* _msg = _internal_mutable_connection_request_frame();
+  // @@protoc_insertion_point(field_mutable:location.nearby.mediums.MultiplexControlFrame.connection_request_frame)
+  return _msg;
+}
+
+// .location.nearby.mediums.ConnectionResponseFrame connection_response_frame = 3;
+inline bool MultiplexControlFrame::_internal_has_connection_response_frame() const {
+  return Frame_case() == kConnectionResponseFrame;
+}
+inline bool MultiplexControlFrame::has_connection_response_frame() const {
+  return _internal_has_connection_response_frame();
+}
+inline void MultiplexControlFrame::set_has_connection_response_frame() {
+  _oneof_case_[0] = kConnectionResponseFrame;
+}
+inline void MultiplexControlFrame::clear_connection_response_frame() {
+  if (_internal_has_connection_response_frame()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete Frame_.connection_response_frame_;
+    }
+    clear_has_Frame();
+  }
+}
+inline ::location::nearby::mediums::ConnectionResponseFrame* MultiplexControlFrame::release_connection_response_frame() {
+  // @@protoc_insertion_point(field_release:location.nearby.mediums.MultiplexControlFrame.connection_response_frame)
+  if (_internal_has_connection_response_frame()) {
+    clear_has_Frame();
+      ::location::nearby::mediums::ConnectionResponseFrame* temp = Frame_.connection_response_frame_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    Frame_.connection_response_frame_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::location::nearby::mediums::ConnectionResponseFrame& MultiplexControlFrame::_internal_connection_response_frame() const {
+  return _internal_has_connection_response_frame()
+      ? *Frame_.connection_response_frame_
+      : reinterpret_cast< ::location::nearby::mediums::ConnectionResponseFrame&>(::location::nearby::mediums::_ConnectionResponseFrame_default_instance_);
+}
+inline const ::location::nearby::mediums::ConnectionResponseFrame& MultiplexControlFrame::connection_response_frame() const {
+  // @@protoc_insertion_point(field_get:location.nearby.mediums.MultiplexControlFrame.connection_response_frame)
+  return _internal_connection_response_frame();
+}
+inline ::location::nearby::mediums::ConnectionResponseFrame* MultiplexControlFrame::unsafe_arena_release_connection_response_frame() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:location.nearby.mediums.MultiplexControlFrame.connection_response_frame)
+  if (_internal_has_connection_response_frame()) {
+    clear_has_Frame();
+    ::location::nearby::mediums::ConnectionResponseFrame* temp = Frame_.connection_response_frame_;
+    Frame_.connection_response_frame_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void MultiplexControlFrame::unsafe_arena_set_allocated_connection_response_frame(::location::nearby::mediums::ConnectionResponseFrame* connection_response_frame) {
+  clear_Frame();
+  if (connection_response_frame) {
+    set_has_connection_response_frame();
+    Frame_.connection_response_frame_ = connection_response_frame;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.mediums.MultiplexControlFrame.connection_response_frame)
+}
+inline ::location::nearby::mediums::ConnectionResponseFrame* MultiplexControlFrame::_internal_mutable_connection_response_frame() {
+  if (!_internal_has_connection_response_frame()) {
+    clear_Frame();
+    set_has_connection_response_frame();
+    Frame_.connection_response_frame_ = CreateMaybeMessage< ::location::nearby::mediums::ConnectionResponseFrame >(GetArenaForAllocation());
+  }
+  return Frame_.connection_response_frame_;
+}
+inline ::location::nearby::mediums::ConnectionResponseFrame* MultiplexControlFrame::mutable_connection_response_frame() {
+  ::location::nearby::mediums::ConnectionResponseFrame* _msg = _internal_mutable_connection_response_frame();
+  // @@protoc_insertion_point(field_mutable:location.nearby.mediums.MultiplexControlFrame.connection_response_frame)
+  return _msg;
+}
+
+// .location.nearby.mediums.DisconnectFrame disconnect_frame = 4;
+inline bool MultiplexControlFrame::_internal_has_disconnect_frame() const {
+  return Frame_case() == kDisconnectFrame;
+}
+inline bool MultiplexControlFrame::has_disconnect_frame() const {
+  return _internal_has_disconnect_frame();
+}
+inline void MultiplexControlFrame::set_has_disconnect_frame() {
+  _oneof_case_[0] = kDisconnectFrame;
+}
+inline void MultiplexControlFrame::clear_disconnect_frame() {
+  if (_internal_has_disconnect_frame()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete Frame_.disconnect_frame_;
+    }
+    clear_has_Frame();
+  }
+}
+inline ::location::nearby::mediums::DisconnectFrame* MultiplexControlFrame::release_disconnect_frame() {
+  // @@protoc_insertion_point(field_release:location.nearby.mediums.MultiplexControlFrame.disconnect_frame)
+  if (_internal_has_disconnect_frame()) {
+    clear_has_Frame();
+      ::location::nearby::mediums::DisconnectFrame* temp = Frame_.disconnect_frame_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    Frame_.disconnect_frame_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::location::nearby::mediums::DisconnectFrame& MultiplexControlFrame::_internal_disconnect_frame() const {
+  return _internal_has_disconnect_frame()
+      ? *Frame_.disconnect_frame_
+      : reinterpret_cast< ::location::nearby::mediums::DisconnectFrame&>(::location::nearby::mediums::_DisconnectFrame_default_instance_);
+}
+inline const ::location::nearby::mediums::DisconnectFrame& MultiplexControlFrame::disconnect_frame() const {
+  // @@protoc_insertion_point(field_get:location.nearby.mediums.MultiplexControlFrame.disconnect_frame)
+  return _internal_disconnect_frame();
+}
+inline ::location::nearby::mediums::DisconnectFrame* MultiplexControlFrame::unsafe_arena_release_disconnect_frame() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:location.nearby.mediums.MultiplexControlFrame.disconnect_frame)
+  if (_internal_has_disconnect_frame()) {
+    clear_has_Frame();
+    ::location::nearby::mediums::DisconnectFrame* temp = Frame_.disconnect_frame_;
+    Frame_.disconnect_frame_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void MultiplexControlFrame::unsafe_arena_set_allocated_disconnect_frame(::location::nearby::mediums::DisconnectFrame* disconnect_frame) {
+  clear_Frame();
+  if (disconnect_frame) {
+    set_has_disconnect_frame();
+    Frame_.disconnect_frame_ = disconnect_frame;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.mediums.MultiplexControlFrame.disconnect_frame)
+}
+inline ::location::nearby::mediums::DisconnectFrame* MultiplexControlFrame::_internal_mutable_disconnect_frame() {
+  if (!_internal_has_disconnect_frame()) {
+    clear_Frame();
+    set_has_disconnect_frame();
+    Frame_.disconnect_frame_ = CreateMaybeMessage< ::location::nearby::mediums::DisconnectFrame >(GetArenaForAllocation());
+  }
+  return Frame_.disconnect_frame_;
+}
+inline ::location::nearby::mediums::DisconnectFrame* MultiplexControlFrame::mutable_disconnect_frame() {
+  ::location::nearby::mediums::DisconnectFrame* _msg = _internal_mutable_disconnect_frame();
+  // @@protoc_insertion_point(field_mutable:location.nearby.mediums.MultiplexControlFrame.disconnect_frame)
+  return _msg;
+}
+
+inline bool MultiplexControlFrame::has_Frame() const {
+  return Frame_case() != FRAME_NOT_SET;
+}
+inline void MultiplexControlFrame::clear_has_Frame() {
+  _oneof_case_[0] = FRAME_NOT_SET;
+}
+inline MultiplexControlFrame::FrameCase MultiplexControlFrame::Frame_case() const {
+  return MultiplexControlFrame::FrameCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// ConnectionRequestFrame
+
+// -------------------------------------------------------------------
+
+// ConnectionResponseFrame
+
+// optional .location.nearby.mediums.ConnectionResponseFrame.ConnectionResponseCode connection_response_code = 1;
+inline bool ConnectionResponseFrame::_internal_has_connection_response_code() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ConnectionResponseFrame::has_connection_response_code() const {
+  return _internal_has_connection_response_code();
+}
+inline void ConnectionResponseFrame::clear_connection_response_code() {
+  connection_response_code_ = 0;
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::location::nearby::mediums::ConnectionResponseFrame_ConnectionResponseCode ConnectionResponseFrame::_internal_connection_response_code() const {
+  return static_cast< ::location::nearby::mediums::ConnectionResponseFrame_ConnectionResponseCode >(connection_response_code_);
+}
+inline ::location::nearby::mediums::ConnectionResponseFrame_ConnectionResponseCode ConnectionResponseFrame::connection_response_code() const {
+  // @@protoc_insertion_point(field_get:location.nearby.mediums.ConnectionResponseFrame.connection_response_code)
+  return _internal_connection_response_code();
+}
+inline void ConnectionResponseFrame::_internal_set_connection_response_code(::location::nearby::mediums::ConnectionResponseFrame_ConnectionResponseCode value) {
+  assert(::location::nearby::mediums::ConnectionResponseFrame_ConnectionResponseCode_IsValid(value));
+  _has_bits_[0] |= 0x00000001u;
+  connection_response_code_ = value;
+}
+inline void ConnectionResponseFrame::set_connection_response_code(::location::nearby::mediums::ConnectionResponseFrame_ConnectionResponseCode value) {
+  _internal_set_connection_response_code(value);
+  // @@protoc_insertion_point(field_set:location.nearby.mediums.ConnectionResponseFrame.connection_response_code)
+}
+
+// -------------------------------------------------------------------
+
+// DisconnectFrame
+
+// -------------------------------------------------------------------
+
+// MultiplexDataFrame
+
+// optional bytes data = 1;
+inline bool MultiplexDataFrame::_internal_has_data() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool MultiplexDataFrame::has_data() const {
+  return _internal_has_data();
+}
+inline void MultiplexDataFrame::clear_data() {
+  data_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& MultiplexDataFrame::data() const {
+  // @@protoc_insertion_point(field_get:location.nearby.mediums.MultiplexDataFrame.data)
+  return _internal_data();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MultiplexDataFrame::set_data(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ data_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:location.nearby.mediums.MultiplexDataFrame.data)
+}
+inline std::string* MultiplexDataFrame::mutable_data() {
+  std::string* _s = _internal_mutable_data();
+  // @@protoc_insertion_point(field_mutable:location.nearby.mediums.MultiplexDataFrame.data)
+  return _s;
+}
+inline const std::string& MultiplexDataFrame::_internal_data() const {
+  return data_.Get();
+}
+inline void MultiplexDataFrame::_internal_set_data(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* MultiplexDataFrame::_internal_mutable_data() {
+  _has_bits_[0] |= 0x00000001u;
+  return data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* MultiplexDataFrame::release_data() {
+  // @@protoc_insertion_point(field_release:location.nearby.mediums.MultiplexDataFrame.data)
+  if (!_internal_has_data()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  auto* p = data_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (data_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
+    data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void MultiplexDataFrame::set_allocated_data(std::string* data) {
+  if (data != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), data,
+      GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (data_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
+    data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:location.nearby.mediums.MultiplexDataFrame.data)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace mediums
+}  // namespace nearby
+}  // namespace location
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::location::nearby::mediums::MultiplexFrame_MultiplexFrameType> : ::std::true_type {};
+template <> struct is_proto_enum< ::location::nearby::mediums::MultiplexControlFrame_MultiplexControlFrameType> : ::std::true_type {};
+template <> struct is_proto_enum< ::location::nearby::mediums::ConnectionResponseFrame_ConnectionResponseCode> : ::std::true_type {};
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_proto_2fmediums_2fmultiplex_5fframes_2eproto