nearby/compiled_proto/presence/proto/presence_frame.pb.h

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

#ifndef GOOGLE_PROTOBUF_INCLUDED_presence_2fproto_2fpresence_5fframe_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_presence_2fproto_2fpresence_5fframe_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/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_presence_2fproto_2fpresence_5fframe_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_presence_2fproto_2fpresence_5fframe_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[9]
    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[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_presence_2fproto_2fpresence_5fframe_2eproto;
namespace nearby {
namespace presence {
class ConnectionInitFrame;
struct ConnectionInitFrameDefaultTypeInternal;
extern ConnectionInitFrameDefaultTypeInternal _ConnectionInitFrame_default_instance_;
class ControlFrame;
struct ControlFrameDefaultTypeInternal;
extern ControlFrameDefaultTypeInternal _ControlFrame_default_instance_;
class DeviceIdentityFrame;
struct DeviceIdentityFrameDefaultTypeInternal;
extern DeviceIdentityFrameDefaultTypeInternal _DeviceIdentityFrame_default_instance_;
class PresenceAuthenticationFrame;
struct PresenceAuthenticationFrameDefaultTypeInternal;
extern PresenceAuthenticationFrameDefaultTypeInternal _PresenceAuthenticationFrame_default_instance_;
class PresenceFrame;
struct PresenceFrameDefaultTypeInternal;
extern PresenceFrameDefaultTypeInternal _PresenceFrame_default_instance_;
class UwbConnectionInfo;
struct UwbConnectionInfoDefaultTypeInternal;
extern UwbConnectionInfoDefaultTypeInternal _UwbConnectionInfo_default_instance_;
class UwbControleeCapabilities;
struct UwbControleeCapabilitiesDefaultTypeInternal;
extern UwbControleeCapabilitiesDefaultTypeInternal _UwbControleeCapabilities_default_instance_;
class UwbMultiChipInfo;
struct UwbMultiChipInfoDefaultTypeInternal;
extern UwbMultiChipInfoDefaultTypeInternal _UwbMultiChipInfo_default_instance_;
class V1Frame;
struct V1FrameDefaultTypeInternal;
extern V1FrameDefaultTypeInternal _V1Frame_default_instance_;
}  // namespace presence
}  // namespace nearby
PROTOBUF_NAMESPACE_OPEN
template<> ::nearby::presence::ConnectionInitFrame* Arena::CreateMaybeMessage<::nearby::presence::ConnectionInitFrame>(Arena*);
template<> ::nearby::presence::ControlFrame* Arena::CreateMaybeMessage<::nearby::presence::ControlFrame>(Arena*);
template<> ::nearby::presence::DeviceIdentityFrame* Arena::CreateMaybeMessage<::nearby::presence::DeviceIdentityFrame>(Arena*);
template<> ::nearby::presence::PresenceAuthenticationFrame* Arena::CreateMaybeMessage<::nearby::presence::PresenceAuthenticationFrame>(Arena*);
template<> ::nearby::presence::PresenceFrame* Arena::CreateMaybeMessage<::nearby::presence::PresenceFrame>(Arena*);
template<> ::nearby::presence::UwbConnectionInfo* Arena::CreateMaybeMessage<::nearby::presence::UwbConnectionInfo>(Arena*);
template<> ::nearby::presence::UwbControleeCapabilities* Arena::CreateMaybeMessage<::nearby::presence::UwbControleeCapabilities>(Arena*);
template<> ::nearby::presence::UwbMultiChipInfo* Arena::CreateMaybeMessage<::nearby::presence::UwbMultiChipInfo>(Arena*);
template<> ::nearby::presence::V1Frame* Arena::CreateMaybeMessage<::nearby::presence::V1Frame>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace nearby {
namespace presence {

enum PresenceFrame_Version : int {
  PresenceFrame_Version_UNKNOWN_VERSION = 0,
  PresenceFrame_Version_VERSION_1 = 1
};
bool PresenceFrame_Version_IsValid(int value);
constexpr PresenceFrame_Version PresenceFrame_Version_Version_MIN = PresenceFrame_Version_UNKNOWN_VERSION;
constexpr PresenceFrame_Version PresenceFrame_Version_Version_MAX = PresenceFrame_Version_VERSION_1;
constexpr int PresenceFrame_Version_Version_ARRAYSIZE = PresenceFrame_Version_Version_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PresenceFrame_Version_descriptor();
template<typename T>
inline const std::string& PresenceFrame_Version_Name(T enum_t_value) {
  static_assert(::std::is_same<T, PresenceFrame_Version>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function PresenceFrame_Version_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    PresenceFrame_Version_descriptor(), enum_t_value);
}
inline bool PresenceFrame_Version_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PresenceFrame_Version* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PresenceFrame_Version>(
    PresenceFrame_Version_descriptor(), name, value);
}
enum ControlFrame_ControlType : int {
  ControlFrame_ControlType_UNKNOWN_TYPE = 0,
  ControlFrame_ControlType_KEEP_ALIVE = 1,
  ControlFrame_ControlType_DISCONNECT = 2
};
bool ControlFrame_ControlType_IsValid(int value);
constexpr ControlFrame_ControlType ControlFrame_ControlType_ControlType_MIN = ControlFrame_ControlType_UNKNOWN_TYPE;
constexpr ControlFrame_ControlType ControlFrame_ControlType_ControlType_MAX = ControlFrame_ControlType_DISCONNECT;
constexpr int ControlFrame_ControlType_ControlType_ARRAYSIZE = ControlFrame_ControlType_ControlType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ControlFrame_ControlType_descriptor();
template<typename T>
inline const std::string& ControlFrame_ControlType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ControlFrame_ControlType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ControlFrame_ControlType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ControlFrame_ControlType_descriptor(), enum_t_value);
}
inline bool ControlFrame_ControlType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ControlFrame_ControlType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ControlFrame_ControlType>(
    ControlFrame_ControlType_descriptor(), name, value);
}
// ===================================================================

class PresenceFrame final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:nearby.presence.PresenceFrame) */ {
 public:
  inline PresenceFrame() : PresenceFrame(nullptr) {}
  ~PresenceFrame() override;
  explicit constexpr PresenceFrame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PresenceFrame(const PresenceFrame& from);
  PresenceFrame(PresenceFrame&& from) noexcept
    : PresenceFrame() {
    *this = ::std::move(from);
  }

  inline PresenceFrame& operator=(const PresenceFrame& from) {
    CopyFrom(from);
    return *this;
  }
  inline PresenceFrame& operator=(PresenceFrame&& 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 ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PresenceFrame& default_instance() {
    return *internal_default_instance();
  }
  static inline const PresenceFrame* internal_default_instance() {
    return reinterpret_cast<const PresenceFrame*>(
               &_PresenceFrame_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(PresenceFrame& a, PresenceFrame& b) {
    a.Swap(&b);
  }
  inline void Swap(PresenceFrame* 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(PresenceFrame* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PresenceFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PresenceFrame>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PresenceFrame& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const PresenceFrame& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  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 final;
  void InternalSwap(PresenceFrame* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "nearby.presence.PresenceFrame";
  }
  protected:
  explicit PresenceFrame(::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:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef PresenceFrame_Version Version;
  static constexpr Version UNKNOWN_VERSION =
    PresenceFrame_Version_UNKNOWN_VERSION;
  static constexpr Version VERSION_1 =
    PresenceFrame_Version_VERSION_1;
  static inline bool Version_IsValid(int value) {
    return PresenceFrame_Version_IsValid(value);
  }
  static constexpr Version Version_MIN =
    PresenceFrame_Version_Version_MIN;
  static constexpr Version Version_MAX =
    PresenceFrame_Version_Version_MAX;
  static constexpr int Version_ARRAYSIZE =
    PresenceFrame_Version_Version_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Version_descriptor() {
    return PresenceFrame_Version_descriptor();
  }
  template<typename T>
  static inline const std::string& Version_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Version>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Version_Name.");
    return PresenceFrame_Version_Name(enum_t_value);
  }
  static inline bool Version_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Version* value) {
    return PresenceFrame_Version_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kV1FrameFieldNumber = 1,
  };
  // optional .nearby.presence.V1Frame v1_frame = 1;
  bool has_v1_frame() const;
  private:
  bool _internal_has_v1_frame() const;
  public:
  void clear_v1_frame();
  const ::nearby::presence::V1Frame& v1_frame() const;
  PROTOBUF_NODISCARD ::nearby::presence::V1Frame* release_v1_frame();
  ::nearby::presence::V1Frame* mutable_v1_frame();
  void set_allocated_v1_frame(::nearby::presence::V1Frame* v1_frame);
  private:
  const ::nearby::presence::V1Frame& _internal_v1_frame() const;
  ::nearby::presence::V1Frame* _internal_mutable_v1_frame();
  public:
  void unsafe_arena_set_allocated_v1_frame(
      ::nearby::presence::V1Frame* v1_frame);
  ::nearby::presence::V1Frame* unsafe_arena_release_v1_frame();

  // @@protoc_insertion_point(class_scope:nearby.presence.PresenceFrame)
 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_;
  ::nearby::presence::V1Frame* v1_frame_;
  friend struct ::TableStruct_presence_2fproto_2fpresence_5fframe_2eproto;
};
// -------------------------------------------------------------------

class V1Frame final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:nearby.presence.V1Frame) */ {
 public:
  inline V1Frame() : V1Frame(nullptr) {}
  ~V1Frame() override;
  explicit constexpr V1Frame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  V1Frame(const V1Frame& from);
  V1Frame(V1Frame&& from) noexcept
    : V1Frame() {
    *this = ::std::move(from);
  }

  inline V1Frame& operator=(const V1Frame& from) {
    CopyFrom(from);
    return *this;
  }
  inline V1Frame& operator=(V1Frame&& 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 ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const V1Frame& default_instance() {
    return *internal_default_instance();
  }
  enum MessageCase {
    kControlFrame = 1,
    kDeviceIdentityFrame = 2,
    kConnectionInitFrame = 3,
    kUwbControleeCapabilitiesFrame = 4,
    kUwbConnectionInfo = 5,
    kAuthenticationFrame = 6,
    MESSAGE_NOT_SET = 0,
  };

  static inline const V1Frame* internal_default_instance() {
    return reinterpret_cast<const V1Frame*>(
               &_V1Frame_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(V1Frame& a, V1Frame& b) {
    a.Swap(&b);
  }
  inline void Swap(V1Frame* 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(V1Frame* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  V1Frame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<V1Frame>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const V1Frame& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const V1Frame& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  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 final;
  void InternalSwap(V1Frame* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "nearby.presence.V1Frame";
  }
  protected:
  explicit V1Frame(::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:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kControlFrameFieldNumber = 1,
    kDeviceIdentityFrameFieldNumber = 2,
    kConnectionInitFrameFieldNumber = 3,
    kUwbControleeCapabilitiesFrameFieldNumber = 4,
    kUwbConnectionInfoFieldNumber = 5,
    kAuthenticationFrameFieldNumber = 6,
  };
  // .nearby.presence.ControlFrame control_frame = 1;
  bool has_control_frame() const;
  private:
  bool _internal_has_control_frame() const;
  public:
  void clear_control_frame();
  const ::nearby::presence::ControlFrame& control_frame() const;
  PROTOBUF_NODISCARD ::nearby::presence::ControlFrame* release_control_frame();
  ::nearby::presence::ControlFrame* mutable_control_frame();
  void set_allocated_control_frame(::nearby::presence::ControlFrame* control_frame);
  private:
  const ::nearby::presence::ControlFrame& _internal_control_frame() const;
  ::nearby::presence::ControlFrame* _internal_mutable_control_frame();
  public:
  void unsafe_arena_set_allocated_control_frame(
      ::nearby::presence::ControlFrame* control_frame);
  ::nearby::presence::ControlFrame* unsafe_arena_release_control_frame();

  // .nearby.presence.DeviceIdentityFrame device_identity_frame = 2;
  bool has_device_identity_frame() const;
  private:
  bool _internal_has_device_identity_frame() const;
  public:
  void clear_device_identity_frame();
  const ::nearby::presence::DeviceIdentityFrame& device_identity_frame() const;
  PROTOBUF_NODISCARD ::nearby::presence::DeviceIdentityFrame* release_device_identity_frame();
  ::nearby::presence::DeviceIdentityFrame* mutable_device_identity_frame();
  void set_allocated_device_identity_frame(::nearby::presence::DeviceIdentityFrame* device_identity_frame);
  private:
  const ::nearby::presence::DeviceIdentityFrame& _internal_device_identity_frame() const;
  ::nearby::presence::DeviceIdentityFrame* _internal_mutable_device_identity_frame();
  public:
  void unsafe_arena_set_allocated_device_identity_frame(
      ::nearby::presence::DeviceIdentityFrame* device_identity_frame);
  ::nearby::presence::DeviceIdentityFrame* unsafe_arena_release_device_identity_frame();

  // .nearby.presence.ConnectionInitFrame connection_init_frame = 3;
  bool has_connection_init_frame() const;
  private:
  bool _internal_has_connection_init_frame() const;
  public:
  void clear_connection_init_frame();
  const ::nearby::presence::ConnectionInitFrame& connection_init_frame() const;
  PROTOBUF_NODISCARD ::nearby::presence::ConnectionInitFrame* release_connection_init_frame();
  ::nearby::presence::ConnectionInitFrame* mutable_connection_init_frame();
  void set_allocated_connection_init_frame(::nearby::presence::ConnectionInitFrame* connection_init_frame);
  private:
  const ::nearby::presence::ConnectionInitFrame& _internal_connection_init_frame() const;
  ::nearby::presence::ConnectionInitFrame* _internal_mutable_connection_init_frame();
  public:
  void unsafe_arena_set_allocated_connection_init_frame(
      ::nearby::presence::ConnectionInitFrame* connection_init_frame);
  ::nearby::presence::ConnectionInitFrame* unsafe_arena_release_connection_init_frame();

  // .nearby.presence.UwbControleeCapabilities uwb_controlee_capabilities_frame = 4;
  bool has_uwb_controlee_capabilities_frame() const;
  private:
  bool _internal_has_uwb_controlee_capabilities_frame() const;
  public:
  void clear_uwb_controlee_capabilities_frame();
  const ::nearby::presence::UwbControleeCapabilities& uwb_controlee_capabilities_frame() const;
  PROTOBUF_NODISCARD ::nearby::presence::UwbControleeCapabilities* release_uwb_controlee_capabilities_frame();
  ::nearby::presence::UwbControleeCapabilities* mutable_uwb_controlee_capabilities_frame();
  void set_allocated_uwb_controlee_capabilities_frame(::nearby::presence::UwbControleeCapabilities* uwb_controlee_capabilities_frame);
  private:
  const ::nearby::presence::UwbControleeCapabilities& _internal_uwb_controlee_capabilities_frame() const;
  ::nearby::presence::UwbControleeCapabilities* _internal_mutable_uwb_controlee_capabilities_frame();
  public:
  void unsafe_arena_set_allocated_uwb_controlee_capabilities_frame(
      ::nearby::presence::UwbControleeCapabilities* uwb_controlee_capabilities_frame);
  ::nearby::presence::UwbControleeCapabilities* unsafe_arena_release_uwb_controlee_capabilities_frame();

  // .nearby.presence.UwbConnectionInfo uwb_connection_info = 5;
  bool has_uwb_connection_info() const;
  private:
  bool _internal_has_uwb_connection_info() const;
  public:
  void clear_uwb_connection_info();
  const ::nearby::presence::UwbConnectionInfo& uwb_connection_info() const;
  PROTOBUF_NODISCARD ::nearby::presence::UwbConnectionInfo* release_uwb_connection_info();
  ::nearby::presence::UwbConnectionInfo* mutable_uwb_connection_info();
  void set_allocated_uwb_connection_info(::nearby::presence::UwbConnectionInfo* uwb_connection_info);
  private:
  const ::nearby::presence::UwbConnectionInfo& _internal_uwb_connection_info() const;
  ::nearby::presence::UwbConnectionInfo* _internal_mutable_uwb_connection_info();
  public:
  void unsafe_arena_set_allocated_uwb_connection_info(
      ::nearby::presence::UwbConnectionInfo* uwb_connection_info);
  ::nearby::presence::UwbConnectionInfo* unsafe_arena_release_uwb_connection_info();

  // .nearby.presence.PresenceAuthenticationFrame authentication_frame = 6;
  bool has_authentication_frame() const;
  private:
  bool _internal_has_authentication_frame() const;
  public:
  void clear_authentication_frame();
  const ::nearby::presence::PresenceAuthenticationFrame& authentication_frame() const;
  PROTOBUF_NODISCARD ::nearby::presence::PresenceAuthenticationFrame* release_authentication_frame();
  ::nearby::presence::PresenceAuthenticationFrame* mutable_authentication_frame();
  void set_allocated_authentication_frame(::nearby::presence::PresenceAuthenticationFrame* authentication_frame);
  private:
  const ::nearby::presence::PresenceAuthenticationFrame& _internal_authentication_frame() const;
  ::nearby::presence::PresenceAuthenticationFrame* _internal_mutable_authentication_frame();
  public:
  void unsafe_arena_set_allocated_authentication_frame(
      ::nearby::presence::PresenceAuthenticationFrame* authentication_frame);
  ::nearby::presence::PresenceAuthenticationFrame* unsafe_arena_release_authentication_frame();

  void clear_Message();
  MessageCase Message_case() const;
  // @@protoc_insertion_point(class_scope:nearby.presence.V1Frame)
 private:
  class _Internal;
  void set_has_control_frame();
  void set_has_device_identity_frame();
  void set_has_connection_init_frame();
  void set_has_uwb_controlee_capabilities_frame();
  void set_has_uwb_connection_info();
  void set_has_authentication_frame();

  inline bool has_Message() const;
  inline void clear_has_Message();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  union MessageUnion {
    constexpr MessageUnion() : _constinit_{} {}
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
    ::nearby::presence::ControlFrame* control_frame_;
    ::nearby::presence::DeviceIdentityFrame* device_identity_frame_;
    ::nearby::presence::ConnectionInitFrame* connection_init_frame_;
    ::nearby::presence::UwbControleeCapabilities* uwb_controlee_capabilities_frame_;
    ::nearby::presence::UwbConnectionInfo* uwb_connection_info_;
    ::nearby::presence::PresenceAuthenticationFrame* authentication_frame_;
  } Message_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  uint32_t _oneof_case_[1];

  friend struct ::TableStruct_presence_2fproto_2fpresence_5fframe_2eproto;
};
// -------------------------------------------------------------------

class DeviceIdentityFrame final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:nearby.presence.DeviceIdentityFrame) */ {
 public:
  inline DeviceIdentityFrame() : DeviceIdentityFrame(nullptr) {}
  ~DeviceIdentityFrame() override;
  explicit constexpr DeviceIdentityFrame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  DeviceIdentityFrame(const DeviceIdentityFrame& from);
  DeviceIdentityFrame(DeviceIdentityFrame&& from) noexcept
    : DeviceIdentityFrame() {
    *this = ::std::move(from);
  }

  inline DeviceIdentityFrame& operator=(const DeviceIdentityFrame& from) {
    CopyFrom(from);
    return *this;
  }
  inline DeviceIdentityFrame& operator=(DeviceIdentityFrame&& 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 ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DeviceIdentityFrame& default_instance() {
    return *internal_default_instance();
  }
  static inline const DeviceIdentityFrame* internal_default_instance() {
    return reinterpret_cast<const DeviceIdentityFrame*>(
               &_DeviceIdentityFrame_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(DeviceIdentityFrame& a, DeviceIdentityFrame& b) {
    a.Swap(&b);
  }
  inline void Swap(DeviceIdentityFrame* 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(DeviceIdentityFrame* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  DeviceIdentityFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DeviceIdentityFrame>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DeviceIdentityFrame& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const DeviceIdentityFrame& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  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 final;
  void InternalSwap(DeviceIdentityFrame* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "nearby.presence.DeviceIdentityFrame";
  }
  protected:
  explicit DeviceIdentityFrame(::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:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kActionFieldNumber = 5,
    kDeviceNameFieldNumber = 1,
    kBluetoothMacAddressFieldNumber = 2,
    kDeviceImageUrlFieldNumber = 3,
    kModelIdFieldNumber = 4,
    kDeviceModelNameFieldNumber = 6,
    kDeviceTypeFieldNumber = 7,
  };
  // repeated int32 action = 5 [packed = true];
  int action_size() const;
  private:
  int _internal_action_size() const;
  public:
  void clear_action();
  private:
  int32_t _internal_action(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_action() const;
  void _internal_add_action(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_action();
  public:
  int32_t action(int index) const;
  void set_action(int index, int32_t value);
  void add_action(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      action() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_action();

  // optional string device_name = 1;
  bool has_device_name() const;
  private:
  bool _internal_has_device_name() const;
  public:
  void clear_device_name();
  const std::string& device_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_device_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_device_name();
  PROTOBUF_NODISCARD std::string* release_device_name();
  void set_allocated_device_name(std::string* device_name);
  private:
  const std::string& _internal_device_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_name(const std::string& value);
  std::string* _internal_mutable_device_name();
  public:

  // optional bytes bluetooth_mac_address = 2;
  bool has_bluetooth_mac_address() const;
  private:
  bool _internal_has_bluetooth_mac_address() const;
  public:
  void clear_bluetooth_mac_address();
  const std::string& bluetooth_mac_address() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_bluetooth_mac_address(ArgT0&& arg0, ArgT... args);
  std::string* mutable_bluetooth_mac_address();
  PROTOBUF_NODISCARD std::string* release_bluetooth_mac_address();
  void set_allocated_bluetooth_mac_address(std::string* bluetooth_mac_address);
  private:
  const std::string& _internal_bluetooth_mac_address() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_bluetooth_mac_address(const std::string& value);
  std::string* _internal_mutable_bluetooth_mac_address();
  public:

  // optional string device_image_url = 3;
  bool has_device_image_url() const;
  private:
  bool _internal_has_device_image_url() const;
  public:
  void clear_device_image_url();
  const std::string& device_image_url() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_device_image_url(ArgT0&& arg0, ArgT... args);
  std::string* mutable_device_image_url();
  PROTOBUF_NODISCARD std::string* release_device_image_url();
  void set_allocated_device_image_url(std::string* device_image_url);
  private:
  const std::string& _internal_device_image_url() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_image_url(const std::string& value);
  std::string* _internal_mutable_device_image_url();
  public:

  // optional string model_id = 4;
  bool has_model_id() const;
  private:
  bool _internal_has_model_id() const;
  public:
  void clear_model_id();
  const std::string& model_id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_model_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_model_id();
  PROTOBUF_NODISCARD std::string* release_model_id();
  void set_allocated_model_id(std::string* model_id);
  private:
  const std::string& _internal_model_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_model_id(const std::string& value);
  std::string* _internal_mutable_model_id();
  public:

  // optional string device_model_name = 6;
  bool has_device_model_name() const;
  private:
  bool _internal_has_device_model_name() const;
  public:
  void clear_device_model_name();
  const std::string& device_model_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_device_model_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_device_model_name();
  PROTOBUF_NODISCARD std::string* release_device_model_name();
  void set_allocated_device_model_name(std::string* device_model_name);
  private:
  const std::string& _internal_device_model_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_model_name(const std::string& value);
  std::string* _internal_mutable_device_model_name();
  public:

  // optional int32 device_type = 7;
  bool has_device_type() const;
  private:
  bool _internal_has_device_type() const;
  public:
  void clear_device_type();
  int32_t device_type() const;
  void set_device_type(int32_t value);
  private:
  int32_t _internal_device_type() const;
  void _internal_set_device_type(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:nearby.presence.DeviceIdentityFrame)
 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::RepeatedField< int32_t > action_;
  mutable std::atomic<int> _action_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bluetooth_mac_address_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_image_url_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr model_id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_model_name_;
  int32_t device_type_;
  friend struct ::TableStruct_presence_2fproto_2fpresence_5fframe_2eproto;
};
// -------------------------------------------------------------------

class ConnectionInitFrame final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:nearby.presence.ConnectionInitFrame) */ {
 public:
  inline ConnectionInitFrame() : ConnectionInitFrame(nullptr) {}
  ~ConnectionInitFrame() override;
  explicit constexpr ConnectionInitFrame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ConnectionInitFrame(const ConnectionInitFrame& from);
  ConnectionInitFrame(ConnectionInitFrame&& from) noexcept
    : ConnectionInitFrame() {
    *this = ::std::move(from);
  }

  inline ConnectionInitFrame& operator=(const ConnectionInitFrame& from) {
    CopyFrom(from);
    return *this;
  }
  inline ConnectionInitFrame& operator=(ConnectionInitFrame&& 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 ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ConnectionInitFrame& default_instance() {
    return *internal_default_instance();
  }
  static inline const ConnectionInitFrame* internal_default_instance() {
    return reinterpret_cast<const ConnectionInitFrame*>(
               &_ConnectionInitFrame_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(ConnectionInitFrame& a, ConnectionInitFrame& b) {
    a.Swap(&b);
  }
  inline void Swap(ConnectionInitFrame* 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(ConnectionInitFrame* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  ConnectionInitFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ConnectionInitFrame>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ConnectionInitFrame& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ConnectionInitFrame& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  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 final;
  void InternalSwap(ConnectionInitFrame* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "nearby.presence.ConnectionInitFrame";
  }
  protected:
  explicit ConnectionInitFrame(::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:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kActionsFieldNumber = 1,
    kIdentityTypeFieldNumber = 2,
    kUwbEnableFieldNumber = 3,
    kDeviceUniqueIdFieldNumber = 4,
  };
  // repeated int32 actions = 1 [packed = true];
  int actions_size() const;
  private:
  int _internal_actions_size() const;
  public:
  void clear_actions();
  private:
  int32_t _internal_actions(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_actions() const;
  void _internal_add_actions(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_actions();
  public:
  int32_t actions(int index) const;
  void set_actions(int index, int32_t value);
  void add_actions(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      actions() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_actions();

  // optional int32 identity_type = 2;
  bool has_identity_type() const;
  private:
  bool _internal_has_identity_type() const;
  public:
  void clear_identity_type();
  int32_t identity_type() const;
  void set_identity_type(int32_t value);
  private:
  int32_t _internal_identity_type() const;
  void _internal_set_identity_type(int32_t value);
  public:

  // optional bool uwb_enable = 3;
  bool has_uwb_enable() const;
  private:
  bool _internal_has_uwb_enable() const;
  public:
  void clear_uwb_enable();
  bool uwb_enable() const;
  void set_uwb_enable(bool value);
  private:
  bool _internal_uwb_enable() const;
  void _internal_set_uwb_enable(bool value);
  public:

  // optional int64 device_unique_id = 4;
  bool has_device_unique_id() const;
  private:
  bool _internal_has_device_unique_id() const;
  public:
  void clear_device_unique_id();
  int64_t device_unique_id() const;
  void set_device_unique_id(int64_t value);
  private:
  int64_t _internal_device_unique_id() const;
  void _internal_set_device_unique_id(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:nearby.presence.ConnectionInitFrame)
 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::RepeatedField< int32_t > actions_;
  mutable std::atomic<int> _actions_cached_byte_size_;
  int32_t identity_type_;
  bool uwb_enable_;
  int64_t device_unique_id_;
  friend struct ::TableStruct_presence_2fproto_2fpresence_5fframe_2eproto;
};
// -------------------------------------------------------------------

class UwbControleeCapabilities final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:nearby.presence.UwbControleeCapabilities) */ {
 public:
  inline UwbControleeCapabilities() : UwbControleeCapabilities(nullptr) {}
  ~UwbControleeCapabilities() override;
  explicit constexpr UwbControleeCapabilities(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  UwbControleeCapabilities(const UwbControleeCapabilities& from);
  UwbControleeCapabilities(UwbControleeCapabilities&& from) noexcept
    : UwbControleeCapabilities() {
    *this = ::std::move(from);
  }

  inline UwbControleeCapabilities& operator=(const UwbControleeCapabilities& from) {
    CopyFrom(from);
    return *this;
  }
  inline UwbControleeCapabilities& operator=(UwbControleeCapabilities&& 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 ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const UwbControleeCapabilities& default_instance() {
    return *internal_default_instance();
  }
  static inline const UwbControleeCapabilities* internal_default_instance() {
    return reinterpret_cast<const UwbControleeCapabilities*>(
               &_UwbControleeCapabilities_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(UwbControleeCapabilities& a, UwbControleeCapabilities& b) {
    a.Swap(&b);
  }
  inline void Swap(UwbControleeCapabilities* 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(UwbControleeCapabilities* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  UwbControleeCapabilities* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<UwbControleeCapabilities>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const UwbControleeCapabilities& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const UwbControleeCapabilities& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  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 final;
  void InternalSwap(UwbControleeCapabilities* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "nearby.presence.UwbControleeCapabilities";
  }
  protected:
  explicit UwbControleeCapabilities(::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:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSupportedConfigIdsFieldNumber = 2,
    kSupportedChannelsFieldNumber = 3,
    kSupportedNtfConfigsFieldNumber = 13,
    kSupportedSlotDurationsFieldNumber = 15,
    kSupportedRangingUpdateRatesFieldNumber = 16,
    kMultiChipInfoFieldNumber = 18,
    kControleeAddressFieldNumber = 1,
    kSubSessionIdFieldNumber = 5,
    kSubSessionKeyFieldNumber = 6,
    kDeviceUniqueIdFieldNumber = 8,
    kMinRangingIntervalMsFieldNumber = 4,
    kRangingDisabledFieldNumber = 7,
    kIsElevationSupportedFieldNumber = 11,
    kIsRangingIntervalReconfigureSupportedFieldNumber = 14,
    kChipCountFieldNumber = 17,
    kIsDistanceSupportedFieldNumber = 9,
    kIsAzimuthSupportedFieldNumber = 10,
    kMinSlotDurationMsFieldNumber = 12,
  };
  // repeated int32 supported_config_ids = 2 [packed = true];
  int supported_config_ids_size() const;
  private:
  int _internal_supported_config_ids_size() const;
  public:
  void clear_supported_config_ids();
  private:
  int32_t _internal_supported_config_ids(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_supported_config_ids() const;
  void _internal_add_supported_config_ids(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_supported_config_ids();
  public:
  int32_t supported_config_ids(int index) const;
  void set_supported_config_ids(int index, int32_t value);
  void add_supported_config_ids(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      supported_config_ids() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_supported_config_ids();

  // repeated int32 supported_channels = 3 [packed = true];
  int supported_channels_size() const;
  private:
  int _internal_supported_channels_size() const;
  public:
  void clear_supported_channels();
  private:
  int32_t _internal_supported_channels(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_supported_channels() const;
  void _internal_add_supported_channels(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_supported_channels();
  public:
  int32_t supported_channels(int index) const;
  void set_supported_channels(int index, int32_t value);
  void add_supported_channels(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      supported_channels() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_supported_channels();

  // repeated int32 supported_ntf_configs = 13 [packed = true];
  int supported_ntf_configs_size() const;
  private:
  int _internal_supported_ntf_configs_size() const;
  public:
  void clear_supported_ntf_configs();
  private:
  int32_t _internal_supported_ntf_configs(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_supported_ntf_configs() const;
  void _internal_add_supported_ntf_configs(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_supported_ntf_configs();
  public:
  int32_t supported_ntf_configs(int index) const;
  void set_supported_ntf_configs(int index, int32_t value);
  void add_supported_ntf_configs(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      supported_ntf_configs() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_supported_ntf_configs();

  // repeated int32 supported_slot_durations = 15 [packed = true];
  int supported_slot_durations_size() const;
  private:
  int _internal_supported_slot_durations_size() const;
  public:
  void clear_supported_slot_durations();
  private:
  int32_t _internal_supported_slot_durations(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_supported_slot_durations() const;
  void _internal_add_supported_slot_durations(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_supported_slot_durations();
  public:
  int32_t supported_slot_durations(int index) const;
  void set_supported_slot_durations(int index, int32_t value);
  void add_supported_slot_durations(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      supported_slot_durations() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_supported_slot_durations();

  // repeated int32 supported_ranging_update_rates = 16 [packed = true];
  int supported_ranging_update_rates_size() const;
  private:
  int _internal_supported_ranging_update_rates_size() const;
  public:
  void clear_supported_ranging_update_rates();
  private:
  int32_t _internal_supported_ranging_update_rates(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_supported_ranging_update_rates() const;
  void _internal_add_supported_ranging_update_rates(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_supported_ranging_update_rates();
  public:
  int32_t supported_ranging_update_rates(int index) const;
  void set_supported_ranging_update_rates(int index, int32_t value);
  void add_supported_ranging_update_rates(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      supported_ranging_update_rates() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_supported_ranging_update_rates();

  // repeated .nearby.presence.UwbMultiChipInfo multi_chip_info = 18;
  int multi_chip_info_size() const;
  private:
  int _internal_multi_chip_info_size() const;
  public:
  void clear_multi_chip_info();
  ::nearby::presence::UwbMultiChipInfo* mutable_multi_chip_info(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::nearby::presence::UwbMultiChipInfo >*
      mutable_multi_chip_info();
  private:
  const ::nearby::presence::UwbMultiChipInfo& _internal_multi_chip_info(int index) const;
  ::nearby::presence::UwbMultiChipInfo* _internal_add_multi_chip_info();
  public:
  const ::nearby::presence::UwbMultiChipInfo& multi_chip_info(int index) const;
  ::nearby::presence::UwbMultiChipInfo* add_multi_chip_info();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::nearby::presence::UwbMultiChipInfo >&
      multi_chip_info() const;

  // optional bytes controlee_address = 1;
  bool has_controlee_address() const;
  private:
  bool _internal_has_controlee_address() const;
  public:
  void clear_controlee_address();
  const std::string& controlee_address() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_controlee_address(ArgT0&& arg0, ArgT... args);
  std::string* mutable_controlee_address();
  PROTOBUF_NODISCARD std::string* release_controlee_address();
  void set_allocated_controlee_address(std::string* controlee_address);
  private:
  const std::string& _internal_controlee_address() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_controlee_address(const std::string& value);
  std::string* _internal_mutable_controlee_address();
  public:

  // optional bytes sub_session_id = 5;
  bool has_sub_session_id() const;
  private:
  bool _internal_has_sub_session_id() const;
  public:
  void clear_sub_session_id();
  const std::string& sub_session_id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_sub_session_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_sub_session_id();
  PROTOBUF_NODISCARD std::string* release_sub_session_id();
  void set_allocated_sub_session_id(std::string* sub_session_id);
  private:
  const std::string& _internal_sub_session_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sub_session_id(const std::string& value);
  std::string* _internal_mutable_sub_session_id();
  public:

  // optional bytes sub_session_key = 6;
  bool has_sub_session_key() const;
  private:
  bool _internal_has_sub_session_key() const;
  public:
  void clear_sub_session_key();
  const std::string& sub_session_key() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_sub_session_key(ArgT0&& arg0, ArgT... args);
  std::string* mutable_sub_session_key();
  PROTOBUF_NODISCARD std::string* release_sub_session_key();
  void set_allocated_sub_session_key(std::string* sub_session_key);
  private:
  const std::string& _internal_sub_session_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sub_session_key(const std::string& value);
  std::string* _internal_mutable_sub_session_key();
  public:

  // optional int64 device_unique_id = 8;
  bool has_device_unique_id() const;
  private:
  bool _internal_has_device_unique_id() const;
  public:
  void clear_device_unique_id();
  int64_t device_unique_id() const;
  void set_device_unique_id(int64_t value);
  private:
  int64_t _internal_device_unique_id() const;
  void _internal_set_device_unique_id(int64_t value);
  public:

  // optional int32 min_ranging_interval_ms = 4;
  bool has_min_ranging_interval_ms() const;
  private:
  bool _internal_has_min_ranging_interval_ms() const;
  public:
  void clear_min_ranging_interval_ms();
  int32_t min_ranging_interval_ms() const;
  void set_min_ranging_interval_ms(int32_t value);
  private:
  int32_t _internal_min_ranging_interval_ms() const;
  void _internal_set_min_ranging_interval_ms(int32_t value);
  public:

  // optional bool ranging_disabled = 7;
  bool has_ranging_disabled() const;
  private:
  bool _internal_has_ranging_disabled() const;
  public:
  void clear_ranging_disabled();
  bool ranging_disabled() const;
  void set_ranging_disabled(bool value);
  private:
  bool _internal_ranging_disabled() const;
  void _internal_set_ranging_disabled(bool value);
  public:

  // optional bool is_elevation_supported = 11 [default = false];
  bool has_is_elevation_supported() const;
  private:
  bool _internal_has_is_elevation_supported() const;
  public:
  void clear_is_elevation_supported();
  bool is_elevation_supported() const;
  void set_is_elevation_supported(bool value);
  private:
  bool _internal_is_elevation_supported() const;
  void _internal_set_is_elevation_supported(bool value);
  public:

  // optional bool is_ranging_interval_reconfigure_supported = 14 [default = false];
  bool has_is_ranging_interval_reconfigure_supported() const;
  private:
  bool _internal_has_is_ranging_interval_reconfigure_supported() const;
  public:
  void clear_is_ranging_interval_reconfigure_supported();
  bool is_ranging_interval_reconfigure_supported() const;
  void set_is_ranging_interval_reconfigure_supported(bool value);
  private:
  bool _internal_is_ranging_interval_reconfigure_supported() const;
  void _internal_set_is_ranging_interval_reconfigure_supported(bool value);
  public:

  // optional int32 chip_count = 17 [default = 1];
  bool has_chip_count() const;
  private:
  bool _internal_has_chip_count() const;
  public:
  void clear_chip_count();
  int32_t chip_count() const;
  void set_chip_count(int32_t value);
  private:
  int32_t _internal_chip_count() const;
  void _internal_set_chip_count(int32_t value);
  public:

  // optional bool is_distance_supported = 9 [default = true];
  bool has_is_distance_supported() const;
  private:
  bool _internal_has_is_distance_supported() const;
  public:
  void clear_is_distance_supported();
  bool is_distance_supported() const;
  void set_is_distance_supported(bool value);
  private:
  bool _internal_is_distance_supported() const;
  void _internal_set_is_distance_supported(bool value);
  public:

  // optional bool is_azimuth_supported = 10 [default = true];
  bool has_is_azimuth_supported() const;
  private:
  bool _internal_has_is_azimuth_supported() const;
  public:
  void clear_is_azimuth_supported();
  bool is_azimuth_supported() const;
  void set_is_azimuth_supported(bool value);
  private:
  bool _internal_is_azimuth_supported() const;
  void _internal_set_is_azimuth_supported(bool value);
  public:

  // optional float min_slot_duration_ms = 12 [default = 2];
  bool has_min_slot_duration_ms() const;
  private:
  bool _internal_has_min_slot_duration_ms() const;
  public:
  void clear_min_slot_duration_ms();
  float min_slot_duration_ms() const;
  void set_min_slot_duration_ms(float value);
  private:
  float _internal_min_slot_duration_ms() const;
  void _internal_set_min_slot_duration_ms(float value);
  public:

  // @@protoc_insertion_point(class_scope:nearby.presence.UwbControleeCapabilities)
 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::RepeatedField< int32_t > supported_config_ids_;
  mutable std::atomic<int> _supported_config_ids_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > supported_channels_;
  mutable std::atomic<int> _supported_channels_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > supported_ntf_configs_;
  mutable std::atomic<int> _supported_ntf_configs_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > supported_slot_durations_;
  mutable std::atomic<int> _supported_slot_durations_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > supported_ranging_update_rates_;
  mutable std::atomic<int> _supported_ranging_update_rates_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::nearby::presence::UwbMultiChipInfo > multi_chip_info_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr controlee_address_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sub_session_id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sub_session_key_;
  int64_t device_unique_id_;
  int32_t min_ranging_interval_ms_;
  bool ranging_disabled_;
  bool is_elevation_supported_;
  bool is_ranging_interval_reconfigure_supported_;
  int32_t chip_count_;
  bool is_distance_supported_;
  bool is_azimuth_supported_;
  float min_slot_duration_ms_;
  friend struct ::TableStruct_presence_2fproto_2fpresence_5fframe_2eproto;
};
// -------------------------------------------------------------------

class UwbMultiChipInfo final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:nearby.presence.UwbMultiChipInfo) */ {
 public:
  inline UwbMultiChipInfo() : UwbMultiChipInfo(nullptr) {}
  ~UwbMultiChipInfo() override;
  explicit constexpr UwbMultiChipInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  UwbMultiChipInfo(const UwbMultiChipInfo& from);
  UwbMultiChipInfo(UwbMultiChipInfo&& from) noexcept
    : UwbMultiChipInfo() {
    *this = ::std::move(from);
  }

  inline UwbMultiChipInfo& operator=(const UwbMultiChipInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline UwbMultiChipInfo& operator=(UwbMultiChipInfo&& 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 ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const UwbMultiChipInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const UwbMultiChipInfo* internal_default_instance() {
    return reinterpret_cast<const UwbMultiChipInfo*>(
               &_UwbMultiChipInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(UwbMultiChipInfo& a, UwbMultiChipInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(UwbMultiChipInfo* 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(UwbMultiChipInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  UwbMultiChipInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<UwbMultiChipInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const UwbMultiChipInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const UwbMultiChipInfo& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  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 final;
  void InternalSwap(UwbMultiChipInfo* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "nearby.presence.UwbMultiChipInfo";
  }
  protected:
  explicit UwbMultiChipInfo(::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:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kControleeAddressFieldNumber = 1,
    kChipIdFieldNumber = 2,
  };
  // optional bytes controlee_address = 1;
  bool has_controlee_address() const;
  private:
  bool _internal_has_controlee_address() const;
  public:
  void clear_controlee_address();
  const std::string& controlee_address() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_controlee_address(ArgT0&& arg0, ArgT... args);
  std::string* mutable_controlee_address();
  PROTOBUF_NODISCARD std::string* release_controlee_address();
  void set_allocated_controlee_address(std::string* controlee_address);
  private:
  const std::string& _internal_controlee_address() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_controlee_address(const std::string& value);
  std::string* _internal_mutable_controlee_address();
  public:

  // optional string chip_id = 2;
  bool has_chip_id() const;
  private:
  bool _internal_has_chip_id() const;
  public:
  void clear_chip_id();
  const std::string& chip_id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_chip_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_chip_id();
  PROTOBUF_NODISCARD std::string* release_chip_id();
  void set_allocated_chip_id(std::string* chip_id);
  private:
  const std::string& _internal_chip_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_chip_id(const std::string& value);
  std::string* _internal_mutable_chip_id();
  public:

  // @@protoc_insertion_point(class_scope:nearby.presence.UwbMultiChipInfo)
 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 controlee_address_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr chip_id_;
  friend struct ::TableStruct_presence_2fproto_2fpresence_5fframe_2eproto;
};
// -------------------------------------------------------------------

class UwbConnectionInfo final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:nearby.presence.UwbConnectionInfo) */ {
 public:
  inline UwbConnectionInfo() : UwbConnectionInfo(nullptr) {}
  ~UwbConnectionInfo() override;
  explicit constexpr UwbConnectionInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  UwbConnectionInfo(const UwbConnectionInfo& from);
  UwbConnectionInfo(UwbConnectionInfo&& from) noexcept
    : UwbConnectionInfo() {
    *this = ::std::move(from);
  }

  inline UwbConnectionInfo& operator=(const UwbConnectionInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline UwbConnectionInfo& operator=(UwbConnectionInfo&& 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 ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const UwbConnectionInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const UwbConnectionInfo* internal_default_instance() {
    return reinterpret_cast<const UwbConnectionInfo*>(
               &_UwbConnectionInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(UwbConnectionInfo& a, UwbConnectionInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(UwbConnectionInfo* 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(UwbConnectionInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  UwbConnectionInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<UwbConnectionInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const UwbConnectionInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const UwbConnectionInfo& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  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 final;
  void InternalSwap(UwbConnectionInfo* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "nearby.presence.UwbConnectionInfo";
  }
  protected:
  explicit UwbConnectionInfo(::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:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kControllerAddressFieldNumber = 1,
    kVendorIdFieldNumber = 7,
    kStaticStsIvFieldNumber = 8,
    kSessionKeyFieldNumber = 9,
    kChannelFieldNumber = 2,
    kPreambleIndexFieldNumber = 3,
    kConfigIdFieldNumber = 4,
    kRangingIntervalMsFieldNumber = 5,
    kSessionIdFieldNumber = 6,
    kRangingDisabledFieldNumber = 10,
  };
  // optional bytes controller_address = 1;
  bool has_controller_address() const;
  private:
  bool _internal_has_controller_address() const;
  public:
  void clear_controller_address();
  const std::string& controller_address() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_controller_address(ArgT0&& arg0, ArgT... args);
  std::string* mutable_controller_address();
  PROTOBUF_NODISCARD std::string* release_controller_address();
  void set_allocated_controller_address(std::string* controller_address);
  private:
  const std::string& _internal_controller_address() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_controller_address(const std::string& value);
  std::string* _internal_mutable_controller_address();
  public:

  // optional bytes vendor_id = 7;
  bool has_vendor_id() const;
  private:
  bool _internal_has_vendor_id() const;
  public:
  void clear_vendor_id();
  const std::string& vendor_id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_vendor_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_vendor_id();
  PROTOBUF_NODISCARD std::string* release_vendor_id();
  void set_allocated_vendor_id(std::string* vendor_id);
  private:
  const std::string& _internal_vendor_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_vendor_id(const std::string& value);
  std::string* _internal_mutable_vendor_id();
  public:

  // optional bytes static_sts_iv = 8;
  bool has_static_sts_iv() const;
  private:
  bool _internal_has_static_sts_iv() const;
  public:
  void clear_static_sts_iv();
  const std::string& static_sts_iv() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_static_sts_iv(ArgT0&& arg0, ArgT... args);
  std::string* mutable_static_sts_iv();
  PROTOBUF_NODISCARD std::string* release_static_sts_iv();
  void set_allocated_static_sts_iv(std::string* static_sts_iv);
  private:
  const std::string& _internal_static_sts_iv() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_static_sts_iv(const std::string& value);
  std::string* _internal_mutable_static_sts_iv();
  public:

  // optional bytes session_key = 9;
  bool has_session_key() const;
  private:
  bool _internal_has_session_key() const;
  public:
  void clear_session_key();
  const std::string& session_key() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_session_key(ArgT0&& arg0, ArgT... args);
  std::string* mutable_session_key();
  PROTOBUF_NODISCARD std::string* release_session_key();
  void set_allocated_session_key(std::string* session_key);
  private:
  const std::string& _internal_session_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_session_key(const std::string& value);
  std::string* _internal_mutable_session_key();
  public:

  // optional int32 channel = 2;
  bool has_channel() const;
  private:
  bool _internal_has_channel() const;
  public:
  void clear_channel();
  int32_t channel() const;
  void set_channel(int32_t value);
  private:
  int32_t _internal_channel() const;
  void _internal_set_channel(int32_t value);
  public:

  // optional int32 preamble_index = 3;
  bool has_preamble_index() const;
  private:
  bool _internal_has_preamble_index() const;
  public:
  void clear_preamble_index();
  int32_t preamble_index() const;
  void set_preamble_index(int32_t value);
  private:
  int32_t _internal_preamble_index() const;
  void _internal_set_preamble_index(int32_t value);
  public:

  // optional int32 config_id = 4;
  bool has_config_id() const;
  private:
  bool _internal_has_config_id() const;
  public:
  void clear_config_id();
  int32_t config_id() const;
  void set_config_id(int32_t value);
  private:
  int32_t _internal_config_id() const;
  void _internal_set_config_id(int32_t value);
  public:

  // optional int32 ranging_interval_ms = 5;
  bool has_ranging_interval_ms() const;
  private:
  bool _internal_has_ranging_interval_ms() const;
  public:
  void clear_ranging_interval_ms();
  int32_t ranging_interval_ms() const;
  void set_ranging_interval_ms(int32_t value);
  private:
  int32_t _internal_ranging_interval_ms() const;
  void _internal_set_ranging_interval_ms(int32_t value);
  public:

  // optional int32 session_id = 6;
  bool has_session_id() const;
  private:
  bool _internal_has_session_id() const;
  public:
  void clear_session_id();
  int32_t session_id() const;
  void set_session_id(int32_t value);
  private:
  int32_t _internal_session_id() const;
  void _internal_set_session_id(int32_t value);
  public:

  // optional bool ranging_disabled = 10;
  bool has_ranging_disabled() const;
  private:
  bool _internal_has_ranging_disabled() const;
  public:
  void clear_ranging_disabled();
  bool ranging_disabled() const;
  void set_ranging_disabled(bool value);
  private:
  bool _internal_ranging_disabled() const;
  void _internal_set_ranging_disabled(bool value);
  public:

  // @@protoc_insertion_point(class_scope:nearby.presence.UwbConnectionInfo)
 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 controller_address_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr vendor_id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr static_sts_iv_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr session_key_;
  int32_t channel_;
  int32_t preamble_index_;
  int32_t config_id_;
  int32_t ranging_interval_ms_;
  int32_t session_id_;
  bool ranging_disabled_;
  friend struct ::TableStruct_presence_2fproto_2fpresence_5fframe_2eproto;
};
// -------------------------------------------------------------------

class ControlFrame final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:nearby.presence.ControlFrame) */ {
 public:
  inline ControlFrame() : ControlFrame(nullptr) {}
  ~ControlFrame() override;
  explicit constexpr ControlFrame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ControlFrame(const ControlFrame& from);
  ControlFrame(ControlFrame&& from) noexcept
    : ControlFrame() {
    *this = ::std::move(from);
  }

  inline ControlFrame& operator=(const ControlFrame& from) {
    CopyFrom(from);
    return *this;
  }
  inline ControlFrame& operator=(ControlFrame&& 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 ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ControlFrame& default_instance() {
    return *internal_default_instance();
  }
  static inline const ControlFrame* internal_default_instance() {
    return reinterpret_cast<const ControlFrame*>(
               &_ControlFrame_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(ControlFrame& a, ControlFrame& b) {
    a.Swap(&b);
  }
  inline void Swap(ControlFrame* 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(ControlFrame* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  ControlFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ControlFrame>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ControlFrame& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ControlFrame& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  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 final;
  void InternalSwap(ControlFrame* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "nearby.presence.ControlFrame";
  }
  protected:
  explicit ControlFrame(::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:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef ControlFrame_ControlType ControlType;
  static constexpr ControlType UNKNOWN_TYPE =
    ControlFrame_ControlType_UNKNOWN_TYPE;
  static constexpr ControlType KEEP_ALIVE =
    ControlFrame_ControlType_KEEP_ALIVE;
  static constexpr ControlType DISCONNECT =
    ControlFrame_ControlType_DISCONNECT;
  static inline bool ControlType_IsValid(int value) {
    return ControlFrame_ControlType_IsValid(value);
  }
  static constexpr ControlType ControlType_MIN =
    ControlFrame_ControlType_ControlType_MIN;
  static constexpr ControlType ControlType_MAX =
    ControlFrame_ControlType_ControlType_MAX;
  static constexpr int ControlType_ARRAYSIZE =
    ControlFrame_ControlType_ControlType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  ControlType_descriptor() {
    return ControlFrame_ControlType_descriptor();
  }
  template<typename T>
  static inline const std::string& ControlType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ControlType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ControlType_Name.");
    return ControlFrame_ControlType_Name(enum_t_value);
  }
  static inline bool ControlType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      ControlType* value) {
    return ControlFrame_ControlType_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kTypeFieldNumber = 1,
  };
  // optional .nearby.presence.ControlFrame.ControlType type = 1;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::nearby::presence::ControlFrame_ControlType type() const;
  void set_type(::nearby::presence::ControlFrame_ControlType value);
  private:
  ::nearby::presence::ControlFrame_ControlType _internal_type() const;
  void _internal_set_type(::nearby::presence::ControlFrame_ControlType value);
  public:

  // @@protoc_insertion_point(class_scope:nearby.presence.ControlFrame)
 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 type_;
  friend struct ::TableStruct_presence_2fproto_2fpresence_5fframe_2eproto;
};
// -------------------------------------------------------------------

class PresenceAuthenticationFrame final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:nearby.presence.PresenceAuthenticationFrame) */ {
 public:
  inline PresenceAuthenticationFrame() : PresenceAuthenticationFrame(nullptr) {}
  ~PresenceAuthenticationFrame() override;
  explicit constexpr PresenceAuthenticationFrame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PresenceAuthenticationFrame(const PresenceAuthenticationFrame& from);
  PresenceAuthenticationFrame(PresenceAuthenticationFrame&& from) noexcept
    : PresenceAuthenticationFrame() {
    *this = ::std::move(from);
  }

  inline PresenceAuthenticationFrame& operator=(const PresenceAuthenticationFrame& from) {
    CopyFrom(from);
    return *this;
  }
  inline PresenceAuthenticationFrame& operator=(PresenceAuthenticationFrame&& 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 ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PresenceAuthenticationFrame& default_instance() {
    return *internal_default_instance();
  }
  static inline const PresenceAuthenticationFrame* internal_default_instance() {
    return reinterpret_cast<const PresenceAuthenticationFrame*>(
               &_PresenceAuthenticationFrame_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(PresenceAuthenticationFrame& a, PresenceAuthenticationFrame& b) {
    a.Swap(&b);
  }
  inline void Swap(PresenceAuthenticationFrame* 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(PresenceAuthenticationFrame* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PresenceAuthenticationFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PresenceAuthenticationFrame>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PresenceAuthenticationFrame& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const PresenceAuthenticationFrame& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  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 final;
  void InternalSwap(PresenceAuthenticationFrame* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "nearby.presence.PresenceAuthenticationFrame";
  }
  protected:
  explicit PresenceAuthenticationFrame(::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:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPrivateKeySignatureFieldNumber = 2,
    kSharedCredentialIdHashFieldNumber = 3,
    kCredentialIdHashFieldNumber = 4,
    kVersionFieldNumber = 1,
  };
  // optional bytes private_key_signature = 2;
  bool has_private_key_signature() const;
  private:
  bool _internal_has_private_key_signature() const;
  public:
  void clear_private_key_signature();
  const std::string& private_key_signature() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_private_key_signature(ArgT0&& arg0, ArgT... args);
  std::string* mutable_private_key_signature();
  PROTOBUF_NODISCARD std::string* release_private_key_signature();
  void set_allocated_private_key_signature(std::string* private_key_signature);
  private:
  const std::string& _internal_private_key_signature() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_private_key_signature(const std::string& value);
  std::string* _internal_mutable_private_key_signature();
  public:

  // optional bytes shared_credential_id_hash = 3;
  bool has_shared_credential_id_hash() const;
  private:
  bool _internal_has_shared_credential_id_hash() const;
  public:
  void clear_shared_credential_id_hash();
  const std::string& shared_credential_id_hash() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_shared_credential_id_hash(ArgT0&& arg0, ArgT... args);
  std::string* mutable_shared_credential_id_hash();
  PROTOBUF_NODISCARD std::string* release_shared_credential_id_hash();
  void set_allocated_shared_credential_id_hash(std::string* shared_credential_id_hash);
  private:
  const std::string& _internal_shared_credential_id_hash() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_shared_credential_id_hash(const std::string& value);
  std::string* _internal_mutable_shared_credential_id_hash();
  public:

  // optional bytes credential_id_hash = 4 [deprecated = true];
  PROTOBUF_DEPRECATED bool has_credential_id_hash() const;
  private:
  bool _internal_has_credential_id_hash() const;
  public:
  PROTOBUF_DEPRECATED void clear_credential_id_hash();
  PROTOBUF_DEPRECATED const std::string& credential_id_hash() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  PROTOBUF_DEPRECATED void set_credential_id_hash(ArgT0&& arg0, ArgT... args);
  PROTOBUF_DEPRECATED std::string* mutable_credential_id_hash();
  PROTOBUF_NODISCARD PROTOBUF_DEPRECATED std::string* release_credential_id_hash();
  PROTOBUF_DEPRECATED void set_allocated_credential_id_hash(std::string* credential_id_hash);
  private:
  const std::string& _internal_credential_id_hash() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_credential_id_hash(const std::string& value);
  std::string* _internal_mutable_credential_id_hash();
  public:

  // optional int32 version = 1;
  bool has_version() const;
  private:
  bool _internal_has_version() const;
  public:
  void clear_version();
  int32_t version() const;
  void set_version(int32_t value);
  private:
  int32_t _internal_version() const;
  void _internal_set_version(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:nearby.presence.PresenceAuthenticationFrame)
 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 private_key_signature_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr shared_credential_id_hash_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr credential_id_hash_;
  int32_t version_;
  friend struct ::TableStruct_presence_2fproto_2fpresence_5fframe_2eproto;
};
// ===================================================================


// ===================================================================

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

// optional .nearby.presence.V1Frame v1_frame = 1;
inline bool PresenceFrame::_internal_has_v1_frame() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || v1_frame_ != nullptr);
  return value;
}
inline bool PresenceFrame::has_v1_frame() const {
  return _internal_has_v1_frame();
}
inline void PresenceFrame::clear_v1_frame() {
  if (v1_frame_ != nullptr) v1_frame_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::nearby::presence::V1Frame& PresenceFrame::_internal_v1_frame() const {
  const ::nearby::presence::V1Frame* p = v1_frame_;
  return p != nullptr ? *p : reinterpret_cast<const ::nearby::presence::V1Frame&>(
      ::nearby::presence::_V1Frame_default_instance_);
}
inline const ::nearby::presence::V1Frame& PresenceFrame::v1_frame() const {
  // @@protoc_insertion_point(field_get:nearby.presence.PresenceFrame.v1_frame)
  return _internal_v1_frame();
}
inline void PresenceFrame::unsafe_arena_set_allocated_v1_frame(
    ::nearby::presence::V1Frame* v1_frame) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(v1_frame_);
  }
  v1_frame_ = v1_frame;
  if (v1_frame) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.presence.PresenceFrame.v1_frame)
}
inline ::nearby::presence::V1Frame* PresenceFrame::release_v1_frame() {
  _has_bits_[0] &= ~0x00000001u;
  ::nearby::presence::V1Frame* temp = v1_frame_;
  v1_frame_ = 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 ::nearby::presence::V1Frame* PresenceFrame::unsafe_arena_release_v1_frame() {
  // @@protoc_insertion_point(field_release:nearby.presence.PresenceFrame.v1_frame)
  _has_bits_[0] &= ~0x00000001u;
  ::nearby::presence::V1Frame* temp = v1_frame_;
  v1_frame_ = nullptr;
  return temp;
}
inline ::nearby::presence::V1Frame* PresenceFrame::_internal_mutable_v1_frame() {
  _has_bits_[0] |= 0x00000001u;
  if (v1_frame_ == nullptr) {
    auto* p = CreateMaybeMessage<::nearby::presence::V1Frame>(GetArenaForAllocation());
    v1_frame_ = p;
  }
  return v1_frame_;
}
inline ::nearby::presence::V1Frame* PresenceFrame::mutable_v1_frame() {
  ::nearby::presence::V1Frame* _msg = _internal_mutable_v1_frame();
  // @@protoc_insertion_point(field_mutable:nearby.presence.PresenceFrame.v1_frame)
  return _msg;
}
inline void PresenceFrame::set_allocated_v1_frame(::nearby::presence::V1Frame* v1_frame) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete v1_frame_;
  }
  if (v1_frame) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::nearby::presence::V1Frame>::GetOwningArena(v1_frame);
    if (message_arena != submessage_arena) {
      v1_frame = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, v1_frame, submessage_arena);
    }
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  v1_frame_ = v1_frame;
  // @@protoc_insertion_point(field_set_allocated:nearby.presence.PresenceFrame.v1_frame)
}

// -------------------------------------------------------------------

// V1Frame

// .nearby.presence.ControlFrame control_frame = 1;
inline bool V1Frame::_internal_has_control_frame() const {
  return Message_case() == kControlFrame;
}
inline bool V1Frame::has_control_frame() const {
  return _internal_has_control_frame();
}
inline void V1Frame::set_has_control_frame() {
  _oneof_case_[0] = kControlFrame;
}
inline void V1Frame::clear_control_frame() {
  if (_internal_has_control_frame()) {
    if (GetArenaForAllocation() == nullptr) {
      delete Message_.control_frame_;
    }
    clear_has_Message();
  }
}
inline ::nearby::presence::ControlFrame* V1Frame::release_control_frame() {
  // @@protoc_insertion_point(field_release:nearby.presence.V1Frame.control_frame)
  if (_internal_has_control_frame()) {
    clear_has_Message();
      ::nearby::presence::ControlFrame* temp = Message_.control_frame_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    Message_.control_frame_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::nearby::presence::ControlFrame& V1Frame::_internal_control_frame() const {
  return _internal_has_control_frame()
      ? *Message_.control_frame_
      : reinterpret_cast< ::nearby::presence::ControlFrame&>(::nearby::presence::_ControlFrame_default_instance_);
}
inline const ::nearby::presence::ControlFrame& V1Frame::control_frame() const {
  // @@protoc_insertion_point(field_get:nearby.presence.V1Frame.control_frame)
  return _internal_control_frame();
}
inline ::nearby::presence::ControlFrame* V1Frame::unsafe_arena_release_control_frame() {
  // @@protoc_insertion_point(field_unsafe_arena_release:nearby.presence.V1Frame.control_frame)
  if (_internal_has_control_frame()) {
    clear_has_Message();
    ::nearby::presence::ControlFrame* temp = Message_.control_frame_;
    Message_.control_frame_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void V1Frame::unsafe_arena_set_allocated_control_frame(::nearby::presence::ControlFrame* control_frame) {
  clear_Message();
  if (control_frame) {
    set_has_control_frame();
    Message_.control_frame_ = control_frame;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.presence.V1Frame.control_frame)
}
inline ::nearby::presence::ControlFrame* V1Frame::_internal_mutable_control_frame() {
  if (!_internal_has_control_frame()) {
    clear_Message();
    set_has_control_frame();
    Message_.control_frame_ = CreateMaybeMessage< ::nearby::presence::ControlFrame >(GetArenaForAllocation());
  }
  return Message_.control_frame_;
}
inline ::nearby::presence::ControlFrame* V1Frame::mutable_control_frame() {
  ::nearby::presence::ControlFrame* _msg = _internal_mutable_control_frame();
  // @@protoc_insertion_point(field_mutable:nearby.presence.V1Frame.control_frame)
  return _msg;
}

// .nearby.presence.DeviceIdentityFrame device_identity_frame = 2;
inline bool V1Frame::_internal_has_device_identity_frame() const {
  return Message_case() == kDeviceIdentityFrame;
}
inline bool V1Frame::has_device_identity_frame() const {
  return _internal_has_device_identity_frame();
}
inline void V1Frame::set_has_device_identity_frame() {
  _oneof_case_[0] = kDeviceIdentityFrame;
}
inline void V1Frame::clear_device_identity_frame() {
  if (_internal_has_device_identity_frame()) {
    if (GetArenaForAllocation() == nullptr) {
      delete Message_.device_identity_frame_;
    }
    clear_has_Message();
  }
}
inline ::nearby::presence::DeviceIdentityFrame* V1Frame::release_device_identity_frame() {
  // @@protoc_insertion_point(field_release:nearby.presence.V1Frame.device_identity_frame)
  if (_internal_has_device_identity_frame()) {
    clear_has_Message();
      ::nearby::presence::DeviceIdentityFrame* temp = Message_.device_identity_frame_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    Message_.device_identity_frame_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::nearby::presence::DeviceIdentityFrame& V1Frame::_internal_device_identity_frame() const {
  return _internal_has_device_identity_frame()
      ? *Message_.device_identity_frame_
      : reinterpret_cast< ::nearby::presence::DeviceIdentityFrame&>(::nearby::presence::_DeviceIdentityFrame_default_instance_);
}
inline const ::nearby::presence::DeviceIdentityFrame& V1Frame::device_identity_frame() const {
  // @@protoc_insertion_point(field_get:nearby.presence.V1Frame.device_identity_frame)
  return _internal_device_identity_frame();
}
inline ::nearby::presence::DeviceIdentityFrame* V1Frame::unsafe_arena_release_device_identity_frame() {
  // @@protoc_insertion_point(field_unsafe_arena_release:nearby.presence.V1Frame.device_identity_frame)
  if (_internal_has_device_identity_frame()) {
    clear_has_Message();
    ::nearby::presence::DeviceIdentityFrame* temp = Message_.device_identity_frame_;
    Message_.device_identity_frame_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void V1Frame::unsafe_arena_set_allocated_device_identity_frame(::nearby::presence::DeviceIdentityFrame* device_identity_frame) {
  clear_Message();
  if (device_identity_frame) {
    set_has_device_identity_frame();
    Message_.device_identity_frame_ = device_identity_frame;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.presence.V1Frame.device_identity_frame)
}
inline ::nearby::presence::DeviceIdentityFrame* V1Frame::_internal_mutable_device_identity_frame() {
  if (!_internal_has_device_identity_frame()) {
    clear_Message();
    set_has_device_identity_frame();
    Message_.device_identity_frame_ = CreateMaybeMessage< ::nearby::presence::DeviceIdentityFrame >(GetArenaForAllocation());
  }
  return Message_.device_identity_frame_;
}
inline ::nearby::presence::DeviceIdentityFrame* V1Frame::mutable_device_identity_frame() {
  ::nearby::presence::DeviceIdentityFrame* _msg = _internal_mutable_device_identity_frame();
  // @@protoc_insertion_point(field_mutable:nearby.presence.V1Frame.device_identity_frame)
  return _msg;
}

// .nearby.presence.ConnectionInitFrame connection_init_frame = 3;
inline bool V1Frame::_internal_has_connection_init_frame() const {
  return Message_case() == kConnectionInitFrame;
}
inline bool V1Frame::has_connection_init_frame() const {
  return _internal_has_connection_init_frame();
}
inline void V1Frame::set_has_connection_init_frame() {
  _oneof_case_[0] = kConnectionInitFrame;
}
inline void V1Frame::clear_connection_init_frame() {
  if (_internal_has_connection_init_frame()) {
    if (GetArenaForAllocation() == nullptr) {
      delete Message_.connection_init_frame_;
    }
    clear_has_Message();
  }
}
inline ::nearby::presence::ConnectionInitFrame* V1Frame::release_connection_init_frame() {
  // @@protoc_insertion_point(field_release:nearby.presence.V1Frame.connection_init_frame)
  if (_internal_has_connection_init_frame()) {
    clear_has_Message();
      ::nearby::presence::ConnectionInitFrame* temp = Message_.connection_init_frame_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    Message_.connection_init_frame_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::nearby::presence::ConnectionInitFrame& V1Frame::_internal_connection_init_frame() const {
  return _internal_has_connection_init_frame()
      ? *Message_.connection_init_frame_
      : reinterpret_cast< ::nearby::presence::ConnectionInitFrame&>(::nearby::presence::_ConnectionInitFrame_default_instance_);
}
inline const ::nearby::presence::ConnectionInitFrame& V1Frame::connection_init_frame() const {
  // @@protoc_insertion_point(field_get:nearby.presence.V1Frame.connection_init_frame)
  return _internal_connection_init_frame();
}
inline ::nearby::presence::ConnectionInitFrame* V1Frame::unsafe_arena_release_connection_init_frame() {
  // @@protoc_insertion_point(field_unsafe_arena_release:nearby.presence.V1Frame.connection_init_frame)
  if (_internal_has_connection_init_frame()) {
    clear_has_Message();
    ::nearby::presence::ConnectionInitFrame* temp = Message_.connection_init_frame_;
    Message_.connection_init_frame_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void V1Frame::unsafe_arena_set_allocated_connection_init_frame(::nearby::presence::ConnectionInitFrame* connection_init_frame) {
  clear_Message();
  if (connection_init_frame) {
    set_has_connection_init_frame();
    Message_.connection_init_frame_ = connection_init_frame;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.presence.V1Frame.connection_init_frame)
}
inline ::nearby::presence::ConnectionInitFrame* V1Frame::_internal_mutable_connection_init_frame() {
  if (!_internal_has_connection_init_frame()) {
    clear_Message();
    set_has_connection_init_frame();
    Message_.connection_init_frame_ = CreateMaybeMessage< ::nearby::presence::ConnectionInitFrame >(GetArenaForAllocation());
  }
  return Message_.connection_init_frame_;
}
inline ::nearby::presence::ConnectionInitFrame* V1Frame::mutable_connection_init_frame() {
  ::nearby::presence::ConnectionInitFrame* _msg = _internal_mutable_connection_init_frame();
  // @@protoc_insertion_point(field_mutable:nearby.presence.V1Frame.connection_init_frame)
  return _msg;
}

// .nearby.presence.UwbControleeCapabilities uwb_controlee_capabilities_frame = 4;
inline bool V1Frame::_internal_has_uwb_controlee_capabilities_frame() const {
  return Message_case() == kUwbControleeCapabilitiesFrame;
}
inline bool V1Frame::has_uwb_controlee_capabilities_frame() const {
  return _internal_has_uwb_controlee_capabilities_frame();
}
inline void V1Frame::set_has_uwb_controlee_capabilities_frame() {
  _oneof_case_[0] = kUwbControleeCapabilitiesFrame;
}
inline void V1Frame::clear_uwb_controlee_capabilities_frame() {
  if (_internal_has_uwb_controlee_capabilities_frame()) {
    if (GetArenaForAllocation() == nullptr) {
      delete Message_.uwb_controlee_capabilities_frame_;
    }
    clear_has_Message();
  }
}
inline ::nearby::presence::UwbControleeCapabilities* V1Frame::release_uwb_controlee_capabilities_frame() {
  // @@protoc_insertion_point(field_release:nearby.presence.V1Frame.uwb_controlee_capabilities_frame)
  if (_internal_has_uwb_controlee_capabilities_frame()) {
    clear_has_Message();
      ::nearby::presence::UwbControleeCapabilities* temp = Message_.uwb_controlee_capabilities_frame_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    Message_.uwb_controlee_capabilities_frame_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::nearby::presence::UwbControleeCapabilities& V1Frame::_internal_uwb_controlee_capabilities_frame() const {
  return _internal_has_uwb_controlee_capabilities_frame()
      ? *Message_.uwb_controlee_capabilities_frame_
      : reinterpret_cast< ::nearby::presence::UwbControleeCapabilities&>(::nearby::presence::_UwbControleeCapabilities_default_instance_);
}
inline const ::nearby::presence::UwbControleeCapabilities& V1Frame::uwb_controlee_capabilities_frame() const {
  // @@protoc_insertion_point(field_get:nearby.presence.V1Frame.uwb_controlee_capabilities_frame)
  return _internal_uwb_controlee_capabilities_frame();
}
inline ::nearby::presence::UwbControleeCapabilities* V1Frame::unsafe_arena_release_uwb_controlee_capabilities_frame() {
  // @@protoc_insertion_point(field_unsafe_arena_release:nearby.presence.V1Frame.uwb_controlee_capabilities_frame)
  if (_internal_has_uwb_controlee_capabilities_frame()) {
    clear_has_Message();
    ::nearby::presence::UwbControleeCapabilities* temp = Message_.uwb_controlee_capabilities_frame_;
    Message_.uwb_controlee_capabilities_frame_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void V1Frame::unsafe_arena_set_allocated_uwb_controlee_capabilities_frame(::nearby::presence::UwbControleeCapabilities* uwb_controlee_capabilities_frame) {
  clear_Message();
  if (uwb_controlee_capabilities_frame) {
    set_has_uwb_controlee_capabilities_frame();
    Message_.uwb_controlee_capabilities_frame_ = uwb_controlee_capabilities_frame;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.presence.V1Frame.uwb_controlee_capabilities_frame)
}
inline ::nearby::presence::UwbControleeCapabilities* V1Frame::_internal_mutable_uwb_controlee_capabilities_frame() {
  if (!_internal_has_uwb_controlee_capabilities_frame()) {
    clear_Message();
    set_has_uwb_controlee_capabilities_frame();
    Message_.uwb_controlee_capabilities_frame_ = CreateMaybeMessage< ::nearby::presence::UwbControleeCapabilities >(GetArenaForAllocation());
  }
  return Message_.uwb_controlee_capabilities_frame_;
}
inline ::nearby::presence::UwbControleeCapabilities* V1Frame::mutable_uwb_controlee_capabilities_frame() {
  ::nearby::presence::UwbControleeCapabilities* _msg = _internal_mutable_uwb_controlee_capabilities_frame();
  // @@protoc_insertion_point(field_mutable:nearby.presence.V1Frame.uwb_controlee_capabilities_frame)
  return _msg;
}

// .nearby.presence.UwbConnectionInfo uwb_connection_info = 5;
inline bool V1Frame::_internal_has_uwb_connection_info() const {
  return Message_case() == kUwbConnectionInfo;
}
inline bool V1Frame::has_uwb_connection_info() const {
  return _internal_has_uwb_connection_info();
}
inline void V1Frame::set_has_uwb_connection_info() {
  _oneof_case_[0] = kUwbConnectionInfo;
}
inline void V1Frame::clear_uwb_connection_info() {
  if (_internal_has_uwb_connection_info()) {
    if (GetArenaForAllocation() == nullptr) {
      delete Message_.uwb_connection_info_;
    }
    clear_has_Message();
  }
}
inline ::nearby::presence::UwbConnectionInfo* V1Frame::release_uwb_connection_info() {
  // @@protoc_insertion_point(field_release:nearby.presence.V1Frame.uwb_connection_info)
  if (_internal_has_uwb_connection_info()) {
    clear_has_Message();
      ::nearby::presence::UwbConnectionInfo* temp = Message_.uwb_connection_info_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    Message_.uwb_connection_info_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::nearby::presence::UwbConnectionInfo& V1Frame::_internal_uwb_connection_info() const {
  return _internal_has_uwb_connection_info()
      ? *Message_.uwb_connection_info_
      : reinterpret_cast< ::nearby::presence::UwbConnectionInfo&>(::nearby::presence::_UwbConnectionInfo_default_instance_);
}
inline const ::nearby::presence::UwbConnectionInfo& V1Frame::uwb_connection_info() const {
  // @@protoc_insertion_point(field_get:nearby.presence.V1Frame.uwb_connection_info)
  return _internal_uwb_connection_info();
}
inline ::nearby::presence::UwbConnectionInfo* V1Frame::unsafe_arena_release_uwb_connection_info() {
  // @@protoc_insertion_point(field_unsafe_arena_release:nearby.presence.V1Frame.uwb_connection_info)
  if (_internal_has_uwb_connection_info()) {
    clear_has_Message();
    ::nearby::presence::UwbConnectionInfo* temp = Message_.uwb_connection_info_;
    Message_.uwb_connection_info_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void V1Frame::unsafe_arena_set_allocated_uwb_connection_info(::nearby::presence::UwbConnectionInfo* uwb_connection_info) {
  clear_Message();
  if (uwb_connection_info) {
    set_has_uwb_connection_info();
    Message_.uwb_connection_info_ = uwb_connection_info;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.presence.V1Frame.uwb_connection_info)
}
inline ::nearby::presence::UwbConnectionInfo* V1Frame::_internal_mutable_uwb_connection_info() {
  if (!_internal_has_uwb_connection_info()) {
    clear_Message();
    set_has_uwb_connection_info();
    Message_.uwb_connection_info_ = CreateMaybeMessage< ::nearby::presence::UwbConnectionInfo >(GetArenaForAllocation());
  }
  return Message_.uwb_connection_info_;
}
inline ::nearby::presence::UwbConnectionInfo* V1Frame::mutable_uwb_connection_info() {
  ::nearby::presence::UwbConnectionInfo* _msg = _internal_mutable_uwb_connection_info();
  // @@protoc_insertion_point(field_mutable:nearby.presence.V1Frame.uwb_connection_info)
  return _msg;
}

// .nearby.presence.PresenceAuthenticationFrame authentication_frame = 6;
inline bool V1Frame::_internal_has_authentication_frame() const {
  return Message_case() == kAuthenticationFrame;
}
inline bool V1Frame::has_authentication_frame() const {
  return _internal_has_authentication_frame();
}
inline void V1Frame::set_has_authentication_frame() {
  _oneof_case_[0] = kAuthenticationFrame;
}
inline void V1Frame::clear_authentication_frame() {
  if (_internal_has_authentication_frame()) {
    if (GetArenaForAllocation() == nullptr) {
      delete Message_.authentication_frame_;
    }
    clear_has_Message();
  }
}
inline ::nearby::presence::PresenceAuthenticationFrame* V1Frame::release_authentication_frame() {
  // @@protoc_insertion_point(field_release:nearby.presence.V1Frame.authentication_frame)
  if (_internal_has_authentication_frame()) {
    clear_has_Message();
      ::nearby::presence::PresenceAuthenticationFrame* temp = Message_.authentication_frame_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    Message_.authentication_frame_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::nearby::presence::PresenceAuthenticationFrame& V1Frame::_internal_authentication_frame() const {
  return _internal_has_authentication_frame()
      ? *Message_.authentication_frame_
      : reinterpret_cast< ::nearby::presence::PresenceAuthenticationFrame&>(::nearby::presence::_PresenceAuthenticationFrame_default_instance_);
}
inline const ::nearby::presence::PresenceAuthenticationFrame& V1Frame::authentication_frame() const {
  // @@protoc_insertion_point(field_get:nearby.presence.V1Frame.authentication_frame)
  return _internal_authentication_frame();
}
inline ::nearby::presence::PresenceAuthenticationFrame* V1Frame::unsafe_arena_release_authentication_frame() {
  // @@protoc_insertion_point(field_unsafe_arena_release:nearby.presence.V1Frame.authentication_frame)
  if (_internal_has_authentication_frame()) {
    clear_has_Message();
    ::nearby::presence::PresenceAuthenticationFrame* temp = Message_.authentication_frame_;
    Message_.authentication_frame_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void V1Frame::unsafe_arena_set_allocated_authentication_frame(::nearby::presence::PresenceAuthenticationFrame* authentication_frame) {
  clear_Message();
  if (authentication_frame) {
    set_has_authentication_frame();
    Message_.authentication_frame_ = authentication_frame;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.presence.V1Frame.authentication_frame)
}
inline ::nearby::presence::PresenceAuthenticationFrame* V1Frame::_internal_mutable_authentication_frame() {
  if (!_internal_has_authentication_frame()) {
    clear_Message();
    set_has_authentication_frame();
    Message_.authentication_frame_ = CreateMaybeMessage< ::nearby::presence::PresenceAuthenticationFrame >(GetArenaForAllocation());
  }
  return Message_.authentication_frame_;
}
inline ::nearby::presence::PresenceAuthenticationFrame* V1Frame::mutable_authentication_frame() {
  ::nearby::presence::PresenceAuthenticationFrame* _msg = _internal_mutable_authentication_frame();
  // @@protoc_insertion_point(field_mutable:nearby.presence.V1Frame.authentication_frame)
  return _msg;
}

inline bool V1Frame::has_Message() const {
  return Message_case() != MESSAGE_NOT_SET;
}
inline void V1Frame::clear_has_Message() {
  _oneof_case_[0] = MESSAGE_NOT_SET;
}
inline V1Frame::MessageCase V1Frame::Message_case() const {
  return V1Frame::MessageCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// DeviceIdentityFrame

// optional string device_name = 1;
inline bool DeviceIdentityFrame::_internal_has_device_name() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool DeviceIdentityFrame::has_device_name() const {
  return _internal_has_device_name();
}
inline void DeviceIdentityFrame::clear_device_name() {
  device_name_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& DeviceIdentityFrame::device_name() const {
  // @@protoc_insertion_point(field_get:nearby.presence.DeviceIdentityFrame.device_name)
  return _internal_device_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DeviceIdentityFrame::set_device_name(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 device_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:nearby.presence.DeviceIdentityFrame.device_name)
}
inline std::string* DeviceIdentityFrame::mutable_device_name() {
  std::string* _s = _internal_mutable_device_name();
  // @@protoc_insertion_point(field_mutable:nearby.presence.DeviceIdentityFrame.device_name)
  return _s;
}
inline const std::string& DeviceIdentityFrame::_internal_device_name() const {
  return device_name_.Get();
}
inline void DeviceIdentityFrame::_internal_set_device_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  device_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* DeviceIdentityFrame::_internal_mutable_device_name() {
  _has_bits_[0] |= 0x00000001u;
  return device_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* DeviceIdentityFrame::release_device_name() {
  // @@protoc_insertion_point(field_release:nearby.presence.DeviceIdentityFrame.device_name)
  if (!_internal_has_device_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  auto* p = device_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (device_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    device_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void DeviceIdentityFrame::set_allocated_device_name(std::string* device_name) {
  if (device_name != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  device_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_name,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (device_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    device_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:nearby.presence.DeviceIdentityFrame.device_name)
}

// optional bytes bluetooth_mac_address = 2;
inline bool DeviceIdentityFrame::_internal_has_bluetooth_mac_address() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool DeviceIdentityFrame::has_bluetooth_mac_address() const {
  return _internal_has_bluetooth_mac_address();
}
inline void DeviceIdentityFrame::clear_bluetooth_mac_address() {
  bluetooth_mac_address_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& DeviceIdentityFrame::bluetooth_mac_address() const {
  // @@protoc_insertion_point(field_get:nearby.presence.DeviceIdentityFrame.bluetooth_mac_address)
  return _internal_bluetooth_mac_address();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DeviceIdentityFrame::set_bluetooth_mac_address(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000002u;
 bluetooth_mac_address_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:nearby.presence.DeviceIdentityFrame.bluetooth_mac_address)
}
inline std::string* DeviceIdentityFrame::mutable_bluetooth_mac_address() {
  std::string* _s = _internal_mutable_bluetooth_mac_address();
  // @@protoc_insertion_point(field_mutable:nearby.presence.DeviceIdentityFrame.bluetooth_mac_address)
  return _s;
}
inline const std::string& DeviceIdentityFrame::_internal_bluetooth_mac_address() const {
  return bluetooth_mac_address_.Get();
}
inline void DeviceIdentityFrame::_internal_set_bluetooth_mac_address(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  bluetooth_mac_address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* DeviceIdentityFrame::_internal_mutable_bluetooth_mac_address() {
  _has_bits_[0] |= 0x00000002u;
  return bluetooth_mac_address_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* DeviceIdentityFrame::release_bluetooth_mac_address() {
  // @@protoc_insertion_point(field_release:nearby.presence.DeviceIdentityFrame.bluetooth_mac_address)
  if (!_internal_has_bluetooth_mac_address()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  auto* p = bluetooth_mac_address_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (bluetooth_mac_address_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    bluetooth_mac_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void DeviceIdentityFrame::set_allocated_bluetooth_mac_address(std::string* bluetooth_mac_address) {
  if (bluetooth_mac_address != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  bluetooth_mac_address_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), bluetooth_mac_address,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (bluetooth_mac_address_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    bluetooth_mac_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:nearby.presence.DeviceIdentityFrame.bluetooth_mac_address)
}

// optional string device_image_url = 3;
inline bool DeviceIdentityFrame::_internal_has_device_image_url() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool DeviceIdentityFrame::has_device_image_url() const {
  return _internal_has_device_image_url();
}
inline void DeviceIdentityFrame::clear_device_image_url() {
  device_image_url_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000004u;
}
inline const std::string& DeviceIdentityFrame::device_image_url() const {
  // @@protoc_insertion_point(field_get:nearby.presence.DeviceIdentityFrame.device_image_url)
  return _internal_device_image_url();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DeviceIdentityFrame::set_device_image_url(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000004u;
 device_image_url_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:nearby.presence.DeviceIdentityFrame.device_image_url)
}
inline std::string* DeviceIdentityFrame::mutable_device_image_url() {
  std::string* _s = _internal_mutable_device_image_url();
  // @@protoc_insertion_point(field_mutable:nearby.presence.DeviceIdentityFrame.device_image_url)
  return _s;
}
inline const std::string& DeviceIdentityFrame::_internal_device_image_url() const {
  return device_image_url_.Get();
}
inline void DeviceIdentityFrame::_internal_set_device_image_url(const std::string& value) {
  _has_bits_[0] |= 0x00000004u;
  device_image_url_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* DeviceIdentityFrame::_internal_mutable_device_image_url() {
  _has_bits_[0] |= 0x00000004u;
  return device_image_url_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* DeviceIdentityFrame::release_device_image_url() {
  // @@protoc_insertion_point(field_release:nearby.presence.DeviceIdentityFrame.device_image_url)
  if (!_internal_has_device_image_url()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000004u;
  auto* p = device_image_url_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (device_image_url_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    device_image_url_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void DeviceIdentityFrame::set_allocated_device_image_url(std::string* device_image_url) {
  if (device_image_url != nullptr) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  device_image_url_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_image_url,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (device_image_url_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    device_image_url_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:nearby.presence.DeviceIdentityFrame.device_image_url)
}

// optional string model_id = 4;
inline bool DeviceIdentityFrame::_internal_has_model_id() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool DeviceIdentityFrame::has_model_id() const {
  return _internal_has_model_id();
}
inline void DeviceIdentityFrame::clear_model_id() {
  model_id_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000008u;
}
inline const std::string& DeviceIdentityFrame::model_id() const {
  // @@protoc_insertion_point(field_get:nearby.presence.DeviceIdentityFrame.model_id)
  return _internal_model_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DeviceIdentityFrame::set_model_id(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000008u;
 model_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:nearby.presence.DeviceIdentityFrame.model_id)
}
inline std::string* DeviceIdentityFrame::mutable_model_id() {
  std::string* _s = _internal_mutable_model_id();
  // @@protoc_insertion_point(field_mutable:nearby.presence.DeviceIdentityFrame.model_id)
  return _s;
}
inline const std::string& DeviceIdentityFrame::_internal_model_id() const {
  return model_id_.Get();
}
inline void DeviceIdentityFrame::_internal_set_model_id(const std::string& value) {
  _has_bits_[0] |= 0x00000008u;
  model_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* DeviceIdentityFrame::_internal_mutable_model_id() {
  _has_bits_[0] |= 0x00000008u;
  return model_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* DeviceIdentityFrame::release_model_id() {
  // @@protoc_insertion_point(field_release:nearby.presence.DeviceIdentityFrame.model_id)
  if (!_internal_has_model_id()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000008u;
  auto* p = model_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (model_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    model_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void DeviceIdentityFrame::set_allocated_model_id(std::string* model_id) {
  if (model_id != nullptr) {
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  model_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), model_id,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (model_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    model_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:nearby.presence.DeviceIdentityFrame.model_id)
}

// repeated int32 action = 5 [packed = true];
inline int DeviceIdentityFrame::_internal_action_size() const {
  return action_.size();
}
inline int DeviceIdentityFrame::action_size() const {
  return _internal_action_size();
}
inline void DeviceIdentityFrame::clear_action() {
  action_.Clear();
}
inline int32_t DeviceIdentityFrame::_internal_action(int index) const {
  return action_.Get(index);
}
inline int32_t DeviceIdentityFrame::action(int index) const {
  // @@protoc_insertion_point(field_get:nearby.presence.DeviceIdentityFrame.action)
  return _internal_action(index);
}
inline void DeviceIdentityFrame::set_action(int index, int32_t value) {
  action_.Set(index, value);
  // @@protoc_insertion_point(field_set:nearby.presence.DeviceIdentityFrame.action)
}
inline void DeviceIdentityFrame::_internal_add_action(int32_t value) {
  action_.Add(value);
}
inline void DeviceIdentityFrame::add_action(int32_t value) {
  _internal_add_action(value);
  // @@protoc_insertion_point(field_add:nearby.presence.DeviceIdentityFrame.action)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
DeviceIdentityFrame::_internal_action() const {
  return action_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
DeviceIdentityFrame::action() const {
  // @@protoc_insertion_point(field_list:nearby.presence.DeviceIdentityFrame.action)
  return _internal_action();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
DeviceIdentityFrame::_internal_mutable_action() {
  return &action_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
DeviceIdentityFrame::mutable_action() {
  // @@protoc_insertion_point(field_mutable_list:nearby.presence.DeviceIdentityFrame.action)
  return _internal_mutable_action();
}

// optional string device_model_name = 6;
inline bool DeviceIdentityFrame::_internal_has_device_model_name() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool DeviceIdentityFrame::has_device_model_name() const {
  return _internal_has_device_model_name();
}
inline void DeviceIdentityFrame::clear_device_model_name() {
  device_model_name_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000010u;
}
inline const std::string& DeviceIdentityFrame::device_model_name() const {
  // @@protoc_insertion_point(field_get:nearby.presence.DeviceIdentityFrame.device_model_name)
  return _internal_device_model_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DeviceIdentityFrame::set_device_model_name(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000010u;
 device_model_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:nearby.presence.DeviceIdentityFrame.device_model_name)
}
inline std::string* DeviceIdentityFrame::mutable_device_model_name() {
  std::string* _s = _internal_mutable_device_model_name();
  // @@protoc_insertion_point(field_mutable:nearby.presence.DeviceIdentityFrame.device_model_name)
  return _s;
}
inline const std::string& DeviceIdentityFrame::_internal_device_model_name() const {
  return device_model_name_.Get();
}
inline void DeviceIdentityFrame::_internal_set_device_model_name(const std::string& value) {
  _has_bits_[0] |= 0x00000010u;
  device_model_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* DeviceIdentityFrame::_internal_mutable_device_model_name() {
  _has_bits_[0] |= 0x00000010u;
  return device_model_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* DeviceIdentityFrame::release_device_model_name() {
  // @@protoc_insertion_point(field_release:nearby.presence.DeviceIdentityFrame.device_model_name)
  if (!_internal_has_device_model_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000010u;
  auto* p = device_model_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (device_model_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    device_model_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void DeviceIdentityFrame::set_allocated_device_model_name(std::string* device_model_name) {
  if (device_model_name != nullptr) {
    _has_bits_[0] |= 0x00000010u;
  } else {
    _has_bits_[0] &= ~0x00000010u;
  }
  device_model_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_model_name,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (device_model_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    device_model_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:nearby.presence.DeviceIdentityFrame.device_model_name)
}

// optional int32 device_type = 7;
inline bool DeviceIdentityFrame::_internal_has_device_type() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool DeviceIdentityFrame::has_device_type() const {
  return _internal_has_device_type();
}
inline void DeviceIdentityFrame::clear_device_type() {
  device_type_ = 0;
  _has_bits_[0] &= ~0x00000020u;
}
inline int32_t DeviceIdentityFrame::_internal_device_type() const {
  return device_type_;
}
inline int32_t DeviceIdentityFrame::device_type() const {
  // @@protoc_insertion_point(field_get:nearby.presence.DeviceIdentityFrame.device_type)
  return _internal_device_type();
}
inline void DeviceIdentityFrame::_internal_set_device_type(int32_t value) {
  _has_bits_[0] |= 0x00000020u;
  device_type_ = value;
}
inline void DeviceIdentityFrame::set_device_type(int32_t value) {
  _internal_set_device_type(value);
  // @@protoc_insertion_point(field_set:nearby.presence.DeviceIdentityFrame.device_type)
}

// -------------------------------------------------------------------

// ConnectionInitFrame

// repeated int32 actions = 1 [packed = true];
inline int ConnectionInitFrame::_internal_actions_size() const {
  return actions_.size();
}
inline int ConnectionInitFrame::actions_size() const {
  return _internal_actions_size();
}
inline void ConnectionInitFrame::clear_actions() {
  actions_.Clear();
}
inline int32_t ConnectionInitFrame::_internal_actions(int index) const {
  return actions_.Get(index);
}
inline int32_t ConnectionInitFrame::actions(int index) const {
  // @@protoc_insertion_point(field_get:nearby.presence.ConnectionInitFrame.actions)
  return _internal_actions(index);
}
inline void ConnectionInitFrame::set_actions(int index, int32_t value) {
  actions_.Set(index, value);
  // @@protoc_insertion_point(field_set:nearby.presence.ConnectionInitFrame.actions)
}
inline void ConnectionInitFrame::_internal_add_actions(int32_t value) {
  actions_.Add(value);
}
inline void ConnectionInitFrame::add_actions(int32_t value) {
  _internal_add_actions(value);
  // @@protoc_insertion_point(field_add:nearby.presence.ConnectionInitFrame.actions)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
ConnectionInitFrame::_internal_actions() const {
  return actions_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
ConnectionInitFrame::actions() const {
  // @@protoc_insertion_point(field_list:nearby.presence.ConnectionInitFrame.actions)
  return _internal_actions();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
ConnectionInitFrame::_internal_mutable_actions() {
  return &actions_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
ConnectionInitFrame::mutable_actions() {
  // @@protoc_insertion_point(field_mutable_list:nearby.presence.ConnectionInitFrame.actions)
  return _internal_mutable_actions();
}

// optional int32 identity_type = 2;
inline bool ConnectionInitFrame::_internal_has_identity_type() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ConnectionInitFrame::has_identity_type() const {
  return _internal_has_identity_type();
}
inline void ConnectionInitFrame::clear_identity_type() {
  identity_type_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline int32_t ConnectionInitFrame::_internal_identity_type() const {
  return identity_type_;
}
inline int32_t ConnectionInitFrame::identity_type() const {
  // @@protoc_insertion_point(field_get:nearby.presence.ConnectionInitFrame.identity_type)
  return _internal_identity_type();
}
inline void ConnectionInitFrame::_internal_set_identity_type(int32_t value) {
  _has_bits_[0] |= 0x00000001u;
  identity_type_ = value;
}
inline void ConnectionInitFrame::set_identity_type(int32_t value) {
  _internal_set_identity_type(value);
  // @@protoc_insertion_point(field_set:nearby.presence.ConnectionInitFrame.identity_type)
}

// optional bool uwb_enable = 3;
inline bool ConnectionInitFrame::_internal_has_uwb_enable() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ConnectionInitFrame::has_uwb_enable() const {
  return _internal_has_uwb_enable();
}
inline void ConnectionInitFrame::clear_uwb_enable() {
  uwb_enable_ = false;
  _has_bits_[0] &= ~0x00000002u;
}
inline bool ConnectionInitFrame::_internal_uwb_enable() const {
  return uwb_enable_;
}
inline bool ConnectionInitFrame::uwb_enable() const {
  // @@protoc_insertion_point(field_get:nearby.presence.ConnectionInitFrame.uwb_enable)
  return _internal_uwb_enable();
}
inline void ConnectionInitFrame::_internal_set_uwb_enable(bool value) {
  _has_bits_[0] |= 0x00000002u;
  uwb_enable_ = value;
}
inline void ConnectionInitFrame::set_uwb_enable(bool value) {
  _internal_set_uwb_enable(value);
  // @@protoc_insertion_point(field_set:nearby.presence.ConnectionInitFrame.uwb_enable)
}

// optional int64 device_unique_id = 4;
inline bool ConnectionInitFrame::_internal_has_device_unique_id() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ConnectionInitFrame::has_device_unique_id() const {
  return _internal_has_device_unique_id();
}
inline void ConnectionInitFrame::clear_device_unique_id() {
  device_unique_id_ = int64_t{0};
  _has_bits_[0] &= ~0x00000004u;
}
inline int64_t ConnectionInitFrame::_internal_device_unique_id() const {
  return device_unique_id_;
}
inline int64_t ConnectionInitFrame::device_unique_id() const {
  // @@protoc_insertion_point(field_get:nearby.presence.ConnectionInitFrame.device_unique_id)
  return _internal_device_unique_id();
}
inline void ConnectionInitFrame::_internal_set_device_unique_id(int64_t value) {
  _has_bits_[0] |= 0x00000004u;
  device_unique_id_ = value;
}
inline void ConnectionInitFrame::set_device_unique_id(int64_t value) {
  _internal_set_device_unique_id(value);
  // @@protoc_insertion_point(field_set:nearby.presence.ConnectionInitFrame.device_unique_id)
}

// -------------------------------------------------------------------

// UwbControleeCapabilities

// optional bytes controlee_address = 1;
inline bool UwbControleeCapabilities::_internal_has_controlee_address() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool UwbControleeCapabilities::has_controlee_address() const {
  return _internal_has_controlee_address();
}
inline void UwbControleeCapabilities::clear_controlee_address() {
  controlee_address_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& UwbControleeCapabilities::controlee_address() const {
  // @@protoc_insertion_point(field_get:nearby.presence.UwbControleeCapabilities.controlee_address)
  return _internal_controlee_address();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void UwbControleeCapabilities::set_controlee_address(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 controlee_address_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:nearby.presence.UwbControleeCapabilities.controlee_address)
}
inline std::string* UwbControleeCapabilities::mutable_controlee_address() {
  std::string* _s = _internal_mutable_controlee_address();
  // @@protoc_insertion_point(field_mutable:nearby.presence.UwbControleeCapabilities.controlee_address)
  return _s;
}
inline const std::string& UwbControleeCapabilities::_internal_controlee_address() const {
  return controlee_address_.Get();
}
inline void UwbControleeCapabilities::_internal_set_controlee_address(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  controlee_address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* UwbControleeCapabilities::_internal_mutable_controlee_address() {
  _has_bits_[0] |= 0x00000001u;
  return controlee_address_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* UwbControleeCapabilities::release_controlee_address() {
  // @@protoc_insertion_point(field_release:nearby.presence.UwbControleeCapabilities.controlee_address)
  if (!_internal_has_controlee_address()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  auto* p = controlee_address_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (controlee_address_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    controlee_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void UwbControleeCapabilities::set_allocated_controlee_address(std::string* controlee_address) {
  if (controlee_address != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  controlee_address_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), controlee_address,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (controlee_address_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    controlee_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:nearby.presence.UwbControleeCapabilities.controlee_address)
}

// repeated int32 supported_config_ids = 2 [packed = true];
inline int UwbControleeCapabilities::_internal_supported_config_ids_size() const {
  return supported_config_ids_.size();
}
inline int UwbControleeCapabilities::supported_config_ids_size() const {
  return _internal_supported_config_ids_size();
}
inline void UwbControleeCapabilities::clear_supported_config_ids() {
  supported_config_ids_.Clear();
}
inline int32_t UwbControleeCapabilities::_internal_supported_config_ids(int index) const {
  return supported_config_ids_.Get(index);
}
inline int32_t UwbControleeCapabilities::supported_config_ids(int index) const {
  // @@protoc_insertion_point(field_get:nearby.presence.UwbControleeCapabilities.supported_config_ids)
  return _internal_supported_config_ids(index);
}
inline void UwbControleeCapabilities::set_supported_config_ids(int index, int32_t value) {
  supported_config_ids_.Set(index, value);
  // @@protoc_insertion_point(field_set:nearby.presence.UwbControleeCapabilities.supported_config_ids)
}
inline void UwbControleeCapabilities::_internal_add_supported_config_ids(int32_t value) {
  supported_config_ids_.Add(value);
}
inline void UwbControleeCapabilities::add_supported_config_ids(int32_t value) {
  _internal_add_supported_config_ids(value);
  // @@protoc_insertion_point(field_add:nearby.presence.UwbControleeCapabilities.supported_config_ids)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
UwbControleeCapabilities::_internal_supported_config_ids() const {
  return supported_config_ids_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
UwbControleeCapabilities::supported_config_ids() const {
  // @@protoc_insertion_point(field_list:nearby.presence.UwbControleeCapabilities.supported_config_ids)
  return _internal_supported_config_ids();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
UwbControleeCapabilities::_internal_mutable_supported_config_ids() {
  return &supported_config_ids_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
UwbControleeCapabilities::mutable_supported_config_ids() {
  // @@protoc_insertion_point(field_mutable_list:nearby.presence.UwbControleeCapabilities.supported_config_ids)
  return _internal_mutable_supported_config_ids();
}

// repeated int32 supported_channels = 3 [packed = true];
inline int UwbControleeCapabilities::_internal_supported_channels_size() const {
  return supported_channels_.size();
}
inline int UwbControleeCapabilities::supported_channels_size() const {
  return _internal_supported_channels_size();
}
inline void UwbControleeCapabilities::clear_supported_channels() {
  supported_channels_.Clear();
}
inline int32_t UwbControleeCapabilities::_internal_supported_channels(int index) const {
  return supported_channels_.Get(index);
}
inline int32_t UwbControleeCapabilities::supported_channels(int index) const {
  // @@protoc_insertion_point(field_get:nearby.presence.UwbControleeCapabilities.supported_channels)
  return _internal_supported_channels(index);
}
inline void UwbControleeCapabilities::set_supported_channels(int index, int32_t value) {
  supported_channels_.Set(index, value);
  // @@protoc_insertion_point(field_set:nearby.presence.UwbControleeCapabilities.supported_channels)
}
inline void UwbControleeCapabilities::_internal_add_supported_channels(int32_t value) {
  supported_channels_.Add(value);
}
inline void UwbControleeCapabilities::add_supported_channels(int32_t value) {
  _internal_add_supported_channels(value);
  // @@protoc_insertion_point(field_add:nearby.presence.UwbControleeCapabilities.supported_channels)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
UwbControleeCapabilities::_internal_supported_channels() const {
  return supported_channels_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
UwbControleeCapabilities::supported_channels() const {
  // @@protoc_insertion_point(field_list:nearby.presence.UwbControleeCapabilities.supported_channels)
  return _internal_supported_channels();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
UwbControleeCapabilities::_internal_mutable_supported_channels() {
  return &supported_channels_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
UwbControleeCapabilities::mutable_supported_channels() {
  // @@protoc_insertion_point(field_mutable_list:nearby.presence.UwbControleeCapabilities.supported_channels)
  return _internal_mutable_supported_channels();
}

// optional int32 min_ranging_interval_ms = 4;
inline bool UwbControleeCapabilities::_internal_has_min_ranging_interval_ms() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool UwbControleeCapabilities::has_min_ranging_interval_ms() const {
  return _internal_has_min_ranging_interval_ms();
}
inline void UwbControleeCapabilities::clear_min_ranging_interval_ms() {
  min_ranging_interval_ms_ = 0;
  _has_bits_[0] &= ~0x00000010u;
}
inline int32_t UwbControleeCapabilities::_internal_min_ranging_interval_ms() const {
  return min_ranging_interval_ms_;
}
inline int32_t UwbControleeCapabilities::min_ranging_interval_ms() const {
  // @@protoc_insertion_point(field_get:nearby.presence.UwbControleeCapabilities.min_ranging_interval_ms)
  return _internal_min_ranging_interval_ms();
}
inline void UwbControleeCapabilities::_internal_set_min_ranging_interval_ms(int32_t value) {
  _has_bits_[0] |= 0x00000010u;
  min_ranging_interval_ms_ = value;
}
inline void UwbControleeCapabilities::set_min_ranging_interval_ms(int32_t value) {
  _internal_set_min_ranging_interval_ms(value);
  // @@protoc_insertion_point(field_set:nearby.presence.UwbControleeCapabilities.min_ranging_interval_ms)
}

// optional bytes sub_session_id = 5;
inline bool UwbControleeCapabilities::_internal_has_sub_session_id() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool UwbControleeCapabilities::has_sub_session_id() const {
  return _internal_has_sub_session_id();
}
inline void UwbControleeCapabilities::clear_sub_session_id() {
  sub_session_id_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& UwbControleeCapabilities::sub_session_id() const {
  // @@protoc_insertion_point(field_get:nearby.presence.UwbControleeCapabilities.sub_session_id)
  return _internal_sub_session_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void UwbControleeCapabilities::set_sub_session_id(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000002u;
 sub_session_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:nearby.presence.UwbControleeCapabilities.sub_session_id)
}
inline std::string* UwbControleeCapabilities::mutable_sub_session_id() {
  std::string* _s = _internal_mutable_sub_session_id();
  // @@protoc_insertion_point(field_mutable:nearby.presence.UwbControleeCapabilities.sub_session_id)
  return _s;
}
inline const std::string& UwbControleeCapabilities::_internal_sub_session_id() const {
  return sub_session_id_.Get();
}
inline void UwbControleeCapabilities::_internal_set_sub_session_id(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  sub_session_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* UwbControleeCapabilities::_internal_mutable_sub_session_id() {
  _has_bits_[0] |= 0x00000002u;
  return sub_session_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* UwbControleeCapabilities::release_sub_session_id() {
  // @@protoc_insertion_point(field_release:nearby.presence.UwbControleeCapabilities.sub_session_id)
  if (!_internal_has_sub_session_id()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  auto* p = sub_session_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (sub_session_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    sub_session_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void UwbControleeCapabilities::set_allocated_sub_session_id(std::string* sub_session_id) {
  if (sub_session_id != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  sub_session_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sub_session_id,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (sub_session_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    sub_session_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:nearby.presence.UwbControleeCapabilities.sub_session_id)
}

// optional bytes sub_session_key = 6;
inline bool UwbControleeCapabilities::_internal_has_sub_session_key() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool UwbControleeCapabilities::has_sub_session_key() const {
  return _internal_has_sub_session_key();
}
inline void UwbControleeCapabilities::clear_sub_session_key() {
  sub_session_key_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000004u;
}
inline const std::string& UwbControleeCapabilities::sub_session_key() const {
  // @@protoc_insertion_point(field_get:nearby.presence.UwbControleeCapabilities.sub_session_key)
  return _internal_sub_session_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void UwbControleeCapabilities::set_sub_session_key(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000004u;
 sub_session_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:nearby.presence.UwbControleeCapabilities.sub_session_key)
}
inline std::string* UwbControleeCapabilities::mutable_sub_session_key() {
  std::string* _s = _internal_mutable_sub_session_key();
  // @@protoc_insertion_point(field_mutable:nearby.presence.UwbControleeCapabilities.sub_session_key)
  return _s;
}
inline const std::string& UwbControleeCapabilities::_internal_sub_session_key() const {
  return sub_session_key_.Get();
}
inline void UwbControleeCapabilities::_internal_set_sub_session_key(const std::string& value) {
  _has_bits_[0] |= 0x00000004u;
  sub_session_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* UwbControleeCapabilities::_internal_mutable_sub_session_key() {
  _has_bits_[0] |= 0x00000004u;
  return sub_session_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* UwbControleeCapabilities::release_sub_session_key() {
  // @@protoc_insertion_point(field_release:nearby.presence.UwbControleeCapabilities.sub_session_key)
  if (!_internal_has_sub_session_key()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000004u;
  auto* p = sub_session_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (sub_session_key_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    sub_session_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void UwbControleeCapabilities::set_allocated_sub_session_key(std::string* sub_session_key) {
  if (sub_session_key != nullptr) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  sub_session_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sub_session_key,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (sub_session_key_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    sub_session_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:nearby.presence.UwbControleeCapabilities.sub_session_key)
}

// optional bool ranging_disabled = 7;
inline bool UwbControleeCapabilities::_internal_has_ranging_disabled() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool UwbControleeCapabilities::has_ranging_disabled() const {
  return _internal_has_ranging_disabled();
}
inline void UwbControleeCapabilities::clear_ranging_disabled() {
  ranging_disabled_ = false;
  _has_bits_[0] &= ~0x00000020u;
}
inline bool UwbControleeCapabilities::_internal_ranging_disabled() const {
  return ranging_disabled_;
}
inline bool UwbControleeCapabilities::ranging_disabled() const {
  // @@protoc_insertion_point(field_get:nearby.presence.UwbControleeCapabilities.ranging_disabled)
  return _internal_ranging_disabled();
}
inline void UwbControleeCapabilities::_internal_set_ranging_disabled(bool value) {
  _has_bits_[0] |= 0x00000020u;
  ranging_disabled_ = value;
}
inline void UwbControleeCapabilities::set_ranging_disabled(bool value) {
  _internal_set_ranging_disabled(value);
  // @@protoc_insertion_point(field_set:nearby.presence.UwbControleeCapabilities.ranging_disabled)
}

// optional int64 device_unique_id = 8;
inline bool UwbControleeCapabilities::_internal_has_device_unique_id() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool UwbControleeCapabilities::has_device_unique_id() const {
  return _internal_has_device_unique_id();
}
inline void UwbControleeCapabilities::clear_device_unique_id() {
  device_unique_id_ = int64_t{0};
  _has_bits_[0] &= ~0x00000008u;
}
inline int64_t UwbControleeCapabilities::_internal_device_unique_id() const {
  return device_unique_id_;
}
inline int64_t UwbControleeCapabilities::device_unique_id() const {
  // @@protoc_insertion_point(field_get:nearby.presence.UwbControleeCapabilities.device_unique_id)
  return _internal_device_unique_id();
}
inline void UwbControleeCapabilities::_internal_set_device_unique_id(int64_t value) {
  _has_bits_[0] |= 0x00000008u;
  device_unique_id_ = value;
}
inline void UwbControleeCapabilities::set_device_unique_id(int64_t value) {
  _internal_set_device_unique_id(value);
  // @@protoc_insertion_point(field_set:nearby.presence.UwbControleeCapabilities.device_unique_id)
}

// optional bool is_distance_supported = 9 [default = true];
inline bool UwbControleeCapabilities::_internal_has_is_distance_supported() const {
  bool value = (_has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool UwbControleeCapabilities::has_is_distance_supported() const {
  return _internal_has_is_distance_supported();
}
inline void UwbControleeCapabilities::clear_is_distance_supported() {
  is_distance_supported_ = true;
  _has_bits_[0] &= ~0x00000200u;
}
inline bool UwbControleeCapabilities::_internal_is_distance_supported() const {
  return is_distance_supported_;
}
inline bool UwbControleeCapabilities::is_distance_supported() const {
  // @@protoc_insertion_point(field_get:nearby.presence.UwbControleeCapabilities.is_distance_supported)
  return _internal_is_distance_supported();
}
inline void UwbControleeCapabilities::_internal_set_is_distance_supported(bool value) {
  _has_bits_[0] |= 0x00000200u;
  is_distance_supported_ = value;
}
inline void UwbControleeCapabilities::set_is_distance_supported(bool value) {
  _internal_set_is_distance_supported(value);
  // @@protoc_insertion_point(field_set:nearby.presence.UwbControleeCapabilities.is_distance_supported)
}

// optional bool is_azimuth_supported = 10 [default = true];
inline bool UwbControleeCapabilities::_internal_has_is_azimuth_supported() const {
  bool value = (_has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool UwbControleeCapabilities::has_is_azimuth_supported() const {
  return _internal_has_is_azimuth_supported();
}
inline void UwbControleeCapabilities::clear_is_azimuth_supported() {
  is_azimuth_supported_ = true;
  _has_bits_[0] &= ~0x00000400u;
}
inline bool UwbControleeCapabilities::_internal_is_azimuth_supported() const {
  return is_azimuth_supported_;
}
inline bool UwbControleeCapabilities::is_azimuth_supported() const {
  // @@protoc_insertion_point(field_get:nearby.presence.UwbControleeCapabilities.is_azimuth_supported)
  return _internal_is_azimuth_supported();
}
inline void UwbControleeCapabilities::_internal_set_is_azimuth_supported(bool value) {
  _has_bits_[0] |= 0x00000400u;
  is_azimuth_supported_ = value;
}
inline void UwbControleeCapabilities::set_is_azimuth_supported(bool value) {
  _internal_set_is_azimuth_supported(value);
  // @@protoc_insertion_point(field_set:nearby.presence.UwbControleeCapabilities.is_azimuth_supported)
}

// optional bool is_elevation_supported = 11 [default = false];
inline bool UwbControleeCapabilities::_internal_has_is_elevation_supported() const {
  bool value = (_has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool UwbControleeCapabilities::has_is_elevation_supported() const {
  return _internal_has_is_elevation_supported();
}
inline void UwbControleeCapabilities::clear_is_elevation_supported() {
  is_elevation_supported_ = false;
  _has_bits_[0] &= ~0x00000040u;
}
inline bool UwbControleeCapabilities::_internal_is_elevation_supported() const {
  return is_elevation_supported_;
}
inline bool UwbControleeCapabilities::is_elevation_supported() const {
  // @@protoc_insertion_point(field_get:nearby.presence.UwbControleeCapabilities.is_elevation_supported)
  return _internal_is_elevation_supported();
}
inline void UwbControleeCapabilities::_internal_set_is_elevation_supported(bool value) {
  _has_bits_[0] |= 0x00000040u;
  is_elevation_supported_ = value;
}
inline void UwbControleeCapabilities::set_is_elevation_supported(bool value) {
  _internal_set_is_elevation_supported(value);
  // @@protoc_insertion_point(field_set:nearby.presence.UwbControleeCapabilities.is_elevation_supported)
}

// optional float min_slot_duration_ms = 12 [default = 2];
inline bool UwbControleeCapabilities::_internal_has_min_slot_duration_ms() const {
  bool value = (_has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool UwbControleeCapabilities::has_min_slot_duration_ms() const {
  return _internal_has_min_slot_duration_ms();
}
inline void UwbControleeCapabilities::clear_min_slot_duration_ms() {
  min_slot_duration_ms_ = 2;
  _has_bits_[0] &= ~0x00000800u;
}
inline float UwbControleeCapabilities::_internal_min_slot_duration_ms() const {
  return min_slot_duration_ms_;
}
inline float UwbControleeCapabilities::min_slot_duration_ms() const {
  // @@protoc_insertion_point(field_get:nearby.presence.UwbControleeCapabilities.min_slot_duration_ms)
  return _internal_min_slot_duration_ms();
}
inline void UwbControleeCapabilities::_internal_set_min_slot_duration_ms(float value) {
  _has_bits_[0] |= 0x00000800u;
  min_slot_duration_ms_ = value;
}
inline void UwbControleeCapabilities::set_min_slot_duration_ms(float value) {
  _internal_set_min_slot_duration_ms(value);
  // @@protoc_insertion_point(field_set:nearby.presence.UwbControleeCapabilities.min_slot_duration_ms)
}

// repeated int32 supported_ntf_configs = 13 [packed = true];
inline int UwbControleeCapabilities::_internal_supported_ntf_configs_size() const {
  return supported_ntf_configs_.size();
}
inline int UwbControleeCapabilities::supported_ntf_configs_size() const {
  return _internal_supported_ntf_configs_size();
}
inline void UwbControleeCapabilities::clear_supported_ntf_configs() {
  supported_ntf_configs_.Clear();
}
inline int32_t UwbControleeCapabilities::_internal_supported_ntf_configs(int index) const {
  return supported_ntf_configs_.Get(index);
}
inline int32_t UwbControleeCapabilities::supported_ntf_configs(int index) const {
  // @@protoc_insertion_point(field_get:nearby.presence.UwbControleeCapabilities.supported_ntf_configs)
  return _internal_supported_ntf_configs(index);
}
inline void UwbControleeCapabilities::set_supported_ntf_configs(int index, int32_t value) {
  supported_ntf_configs_.Set(index, value);
  // @@protoc_insertion_point(field_set:nearby.presence.UwbControleeCapabilities.supported_ntf_configs)
}
inline void UwbControleeCapabilities::_internal_add_supported_ntf_configs(int32_t value) {
  supported_ntf_configs_.Add(value);
}
inline void UwbControleeCapabilities::add_supported_ntf_configs(int32_t value) {
  _internal_add_supported_ntf_configs(value);
  // @@protoc_insertion_point(field_add:nearby.presence.UwbControleeCapabilities.supported_ntf_configs)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
UwbControleeCapabilities::_internal_supported_ntf_configs() const {
  return supported_ntf_configs_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
UwbControleeCapabilities::supported_ntf_configs() const {
  // @@protoc_insertion_point(field_list:nearby.presence.UwbControleeCapabilities.supported_ntf_configs)
  return _internal_supported_ntf_configs();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
UwbControleeCapabilities::_internal_mutable_supported_ntf_configs() {
  return &supported_ntf_configs_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
UwbControleeCapabilities::mutable_supported_ntf_configs() {
  // @@protoc_insertion_point(field_mutable_list:nearby.presence.UwbControleeCapabilities.supported_ntf_configs)
  return _internal_mutable_supported_ntf_configs();
}

// optional bool is_ranging_interval_reconfigure_supported = 14 [default = false];
inline bool UwbControleeCapabilities::_internal_has_is_ranging_interval_reconfigure_supported() const {
  bool value = (_has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool UwbControleeCapabilities::has_is_ranging_interval_reconfigure_supported() const {
  return _internal_has_is_ranging_interval_reconfigure_supported();
}
inline void UwbControleeCapabilities::clear_is_ranging_interval_reconfigure_supported() {
  is_ranging_interval_reconfigure_supported_ = false;
  _has_bits_[0] &= ~0x00000080u;
}
inline bool UwbControleeCapabilities::_internal_is_ranging_interval_reconfigure_supported() const {
  return is_ranging_interval_reconfigure_supported_;
}
inline bool UwbControleeCapabilities::is_ranging_interval_reconfigure_supported() const {
  // @@protoc_insertion_point(field_get:nearby.presence.UwbControleeCapabilities.is_ranging_interval_reconfigure_supported)
  return _internal_is_ranging_interval_reconfigure_supported();
}
inline void UwbControleeCapabilities::_internal_set_is_ranging_interval_reconfigure_supported(bool value) {
  _has_bits_[0] |= 0x00000080u;
  is_ranging_interval_reconfigure_supported_ = value;
}
inline void UwbControleeCapabilities::set_is_ranging_interval_reconfigure_supported(bool value) {
  _internal_set_is_ranging_interval_reconfigure_supported(value);
  // @@protoc_insertion_point(field_set:nearby.presence.UwbControleeCapabilities.is_ranging_interval_reconfigure_supported)
}

// repeated int32 supported_slot_durations = 15 [packed = true];
inline int UwbControleeCapabilities::_internal_supported_slot_durations_size() const {
  return supported_slot_durations_.size();
}
inline int UwbControleeCapabilities::supported_slot_durations_size() const {
  return _internal_supported_slot_durations_size();
}
inline void UwbControleeCapabilities::clear_supported_slot_durations() {
  supported_slot_durations_.Clear();
}
inline int32_t UwbControleeCapabilities::_internal_supported_slot_durations(int index) const {
  return supported_slot_durations_.Get(index);
}
inline int32_t UwbControleeCapabilities::supported_slot_durations(int index) const {
  // @@protoc_insertion_point(field_get:nearby.presence.UwbControleeCapabilities.supported_slot_durations)
  return _internal_supported_slot_durations(index);
}
inline void UwbControleeCapabilities::set_supported_slot_durations(int index, int32_t value) {
  supported_slot_durations_.Set(index, value);
  // @@protoc_insertion_point(field_set:nearby.presence.UwbControleeCapabilities.supported_slot_durations)
}
inline void UwbControleeCapabilities::_internal_add_supported_slot_durations(int32_t value) {
  supported_slot_durations_.Add(value);
}
inline void UwbControleeCapabilities::add_supported_slot_durations(int32_t value) {
  _internal_add_supported_slot_durations(value);
  // @@protoc_insertion_point(field_add:nearby.presence.UwbControleeCapabilities.supported_slot_durations)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
UwbControleeCapabilities::_internal_supported_slot_durations() const {
  return supported_slot_durations_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
UwbControleeCapabilities::supported_slot_durations() const {
  // @@protoc_insertion_point(field_list:nearby.presence.UwbControleeCapabilities.supported_slot_durations)
  return _internal_supported_slot_durations();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
UwbControleeCapabilities::_internal_mutable_supported_slot_durations() {
  return &supported_slot_durations_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
UwbControleeCapabilities::mutable_supported_slot_durations() {
  // @@protoc_insertion_point(field_mutable_list:nearby.presence.UwbControleeCapabilities.supported_slot_durations)
  return _internal_mutable_supported_slot_durations();
}

// repeated int32 supported_ranging_update_rates = 16 [packed = true];
inline int UwbControleeCapabilities::_internal_supported_ranging_update_rates_size() const {
  return supported_ranging_update_rates_.size();
}
inline int UwbControleeCapabilities::supported_ranging_update_rates_size() const {
  return _internal_supported_ranging_update_rates_size();
}
inline void UwbControleeCapabilities::clear_supported_ranging_update_rates() {
  supported_ranging_update_rates_.Clear();
}
inline int32_t UwbControleeCapabilities::_internal_supported_ranging_update_rates(int index) const {
  return supported_ranging_update_rates_.Get(index);
}
inline int32_t UwbControleeCapabilities::supported_ranging_update_rates(int index) const {
  // @@protoc_insertion_point(field_get:nearby.presence.UwbControleeCapabilities.supported_ranging_update_rates)
  return _internal_supported_ranging_update_rates(index);
}
inline void UwbControleeCapabilities::set_supported_ranging_update_rates(int index, int32_t value) {
  supported_ranging_update_rates_.Set(index, value);
  // @@protoc_insertion_point(field_set:nearby.presence.UwbControleeCapabilities.supported_ranging_update_rates)
}
inline void UwbControleeCapabilities::_internal_add_supported_ranging_update_rates(int32_t value) {
  supported_ranging_update_rates_.Add(value);
}
inline void UwbControleeCapabilities::add_supported_ranging_update_rates(int32_t value) {
  _internal_add_supported_ranging_update_rates(value);
  // @@protoc_insertion_point(field_add:nearby.presence.UwbControleeCapabilities.supported_ranging_update_rates)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
UwbControleeCapabilities::_internal_supported_ranging_update_rates() const {
  return supported_ranging_update_rates_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
UwbControleeCapabilities::supported_ranging_update_rates() const {
  // @@protoc_insertion_point(field_list:nearby.presence.UwbControleeCapabilities.supported_ranging_update_rates)
  return _internal_supported_ranging_update_rates();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
UwbControleeCapabilities::_internal_mutable_supported_ranging_update_rates() {
  return &supported_ranging_update_rates_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
UwbControleeCapabilities::mutable_supported_ranging_update_rates() {
  // @@protoc_insertion_point(field_mutable_list:nearby.presence.UwbControleeCapabilities.supported_ranging_update_rates)
  return _internal_mutable_supported_ranging_update_rates();
}

// optional int32 chip_count = 17 [default = 1];
inline bool UwbControleeCapabilities::_internal_has_chip_count() const {
  bool value = (_has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool UwbControleeCapabilities::has_chip_count() const {
  return _internal_has_chip_count();
}
inline void UwbControleeCapabilities::clear_chip_count() {
  chip_count_ = 1;
  _has_bits_[0] &= ~0x00000100u;
}
inline int32_t UwbControleeCapabilities::_internal_chip_count() const {
  return chip_count_;
}
inline int32_t UwbControleeCapabilities::chip_count() const {
  // @@protoc_insertion_point(field_get:nearby.presence.UwbControleeCapabilities.chip_count)
  return _internal_chip_count();
}
inline void UwbControleeCapabilities::_internal_set_chip_count(int32_t value) {
  _has_bits_[0] |= 0x00000100u;
  chip_count_ = value;
}
inline void UwbControleeCapabilities::set_chip_count(int32_t value) {
  _internal_set_chip_count(value);
  // @@protoc_insertion_point(field_set:nearby.presence.UwbControleeCapabilities.chip_count)
}

// repeated .nearby.presence.UwbMultiChipInfo multi_chip_info = 18;
inline int UwbControleeCapabilities::_internal_multi_chip_info_size() const {
  return multi_chip_info_.size();
}
inline int UwbControleeCapabilities::multi_chip_info_size() const {
  return _internal_multi_chip_info_size();
}
inline void UwbControleeCapabilities::clear_multi_chip_info() {
  multi_chip_info_.Clear();
}
inline ::nearby::presence::UwbMultiChipInfo* UwbControleeCapabilities::mutable_multi_chip_info(int index) {
  // @@protoc_insertion_point(field_mutable:nearby.presence.UwbControleeCapabilities.multi_chip_info)
  return multi_chip_info_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::nearby::presence::UwbMultiChipInfo >*
UwbControleeCapabilities::mutable_multi_chip_info() {
  // @@protoc_insertion_point(field_mutable_list:nearby.presence.UwbControleeCapabilities.multi_chip_info)
  return &multi_chip_info_;
}
inline const ::nearby::presence::UwbMultiChipInfo& UwbControleeCapabilities::_internal_multi_chip_info(int index) const {
  return multi_chip_info_.Get(index);
}
inline const ::nearby::presence::UwbMultiChipInfo& UwbControleeCapabilities::multi_chip_info(int index) const {
  // @@protoc_insertion_point(field_get:nearby.presence.UwbControleeCapabilities.multi_chip_info)
  return _internal_multi_chip_info(index);
}
inline ::nearby::presence::UwbMultiChipInfo* UwbControleeCapabilities::_internal_add_multi_chip_info() {
  return multi_chip_info_.Add();
}
inline ::nearby::presence::UwbMultiChipInfo* UwbControleeCapabilities::add_multi_chip_info() {
  ::nearby::presence::UwbMultiChipInfo* _add = _internal_add_multi_chip_info();
  // @@protoc_insertion_point(field_add:nearby.presence.UwbControleeCapabilities.multi_chip_info)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::nearby::presence::UwbMultiChipInfo >&
UwbControleeCapabilities::multi_chip_info() const {
  // @@protoc_insertion_point(field_list:nearby.presence.UwbControleeCapabilities.multi_chip_info)
  return multi_chip_info_;
}

// -------------------------------------------------------------------

// UwbMultiChipInfo

// optional bytes controlee_address = 1;
inline bool UwbMultiChipInfo::_internal_has_controlee_address() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool UwbMultiChipInfo::has_controlee_address() const {
  return _internal_has_controlee_address();
}
inline void UwbMultiChipInfo::clear_controlee_address() {
  controlee_address_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& UwbMultiChipInfo::controlee_address() const {
  // @@protoc_insertion_point(field_get:nearby.presence.UwbMultiChipInfo.controlee_address)
  return _internal_controlee_address();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void UwbMultiChipInfo::set_controlee_address(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 controlee_address_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:nearby.presence.UwbMultiChipInfo.controlee_address)
}
inline std::string* UwbMultiChipInfo::mutable_controlee_address() {
  std::string* _s = _internal_mutable_controlee_address();
  // @@protoc_insertion_point(field_mutable:nearby.presence.UwbMultiChipInfo.controlee_address)
  return _s;
}
inline const std::string& UwbMultiChipInfo::_internal_controlee_address() const {
  return controlee_address_.Get();
}
inline void UwbMultiChipInfo::_internal_set_controlee_address(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  controlee_address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* UwbMultiChipInfo::_internal_mutable_controlee_address() {
  _has_bits_[0] |= 0x00000001u;
  return controlee_address_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* UwbMultiChipInfo::release_controlee_address() {
  // @@protoc_insertion_point(field_release:nearby.presence.UwbMultiChipInfo.controlee_address)
  if (!_internal_has_controlee_address()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  auto* p = controlee_address_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (controlee_address_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    controlee_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void UwbMultiChipInfo::set_allocated_controlee_address(std::string* controlee_address) {
  if (controlee_address != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  controlee_address_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), controlee_address,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (controlee_address_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    controlee_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:nearby.presence.UwbMultiChipInfo.controlee_address)
}

// optional string chip_id = 2;
inline bool UwbMultiChipInfo::_internal_has_chip_id() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool UwbMultiChipInfo::has_chip_id() const {
  return _internal_has_chip_id();
}
inline void UwbMultiChipInfo::clear_chip_id() {
  chip_id_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& UwbMultiChipInfo::chip_id() const {
  // @@protoc_insertion_point(field_get:nearby.presence.UwbMultiChipInfo.chip_id)
  return _internal_chip_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void UwbMultiChipInfo::set_chip_id(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000002u;
 chip_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:nearby.presence.UwbMultiChipInfo.chip_id)
}
inline std::string* UwbMultiChipInfo::mutable_chip_id() {
  std::string* _s = _internal_mutable_chip_id();
  // @@protoc_insertion_point(field_mutable:nearby.presence.UwbMultiChipInfo.chip_id)
  return _s;
}
inline const std::string& UwbMultiChipInfo::_internal_chip_id() const {
  return chip_id_.Get();
}
inline void UwbMultiChipInfo::_internal_set_chip_id(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  chip_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* UwbMultiChipInfo::_internal_mutable_chip_id() {
  _has_bits_[0] |= 0x00000002u;
  return chip_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* UwbMultiChipInfo::release_chip_id() {
  // @@protoc_insertion_point(field_release:nearby.presence.UwbMultiChipInfo.chip_id)
  if (!_internal_has_chip_id()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  auto* p = chip_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (chip_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    chip_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void UwbMultiChipInfo::set_allocated_chip_id(std::string* chip_id) {
  if (chip_id != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  chip_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), chip_id,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (chip_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    chip_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:nearby.presence.UwbMultiChipInfo.chip_id)
}

// -------------------------------------------------------------------

// UwbConnectionInfo

// optional bytes controller_address = 1;
inline bool UwbConnectionInfo::_internal_has_controller_address() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool UwbConnectionInfo::has_controller_address() const {
  return _internal_has_controller_address();
}
inline void UwbConnectionInfo::clear_controller_address() {
  controller_address_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& UwbConnectionInfo::controller_address() const {
  // @@protoc_insertion_point(field_get:nearby.presence.UwbConnectionInfo.controller_address)
  return _internal_controller_address();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void UwbConnectionInfo::set_controller_address(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 controller_address_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:nearby.presence.UwbConnectionInfo.controller_address)
}
inline std::string* UwbConnectionInfo::mutable_controller_address() {
  std::string* _s = _internal_mutable_controller_address();
  // @@protoc_insertion_point(field_mutable:nearby.presence.UwbConnectionInfo.controller_address)
  return _s;
}
inline const std::string& UwbConnectionInfo::_internal_controller_address() const {
  return controller_address_.Get();
}
inline void UwbConnectionInfo::_internal_set_controller_address(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  controller_address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* UwbConnectionInfo::_internal_mutable_controller_address() {
  _has_bits_[0] |= 0x00000001u;
  return controller_address_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* UwbConnectionInfo::release_controller_address() {
  // @@protoc_insertion_point(field_release:nearby.presence.UwbConnectionInfo.controller_address)
  if (!_internal_has_controller_address()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  auto* p = controller_address_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (controller_address_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    controller_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void UwbConnectionInfo::set_allocated_controller_address(std::string* controller_address) {
  if (controller_address != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  controller_address_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), controller_address,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (controller_address_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    controller_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:nearby.presence.UwbConnectionInfo.controller_address)
}

// optional int32 channel = 2;
inline bool UwbConnectionInfo::_internal_has_channel() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool UwbConnectionInfo::has_channel() const {
  return _internal_has_channel();
}
inline void UwbConnectionInfo::clear_channel() {
  channel_ = 0;
  _has_bits_[0] &= ~0x00000010u;
}
inline int32_t UwbConnectionInfo::_internal_channel() const {
  return channel_;
}
inline int32_t UwbConnectionInfo::channel() const {
  // @@protoc_insertion_point(field_get:nearby.presence.UwbConnectionInfo.channel)
  return _internal_channel();
}
inline void UwbConnectionInfo::_internal_set_channel(int32_t value) {
  _has_bits_[0] |= 0x00000010u;
  channel_ = value;
}
inline void UwbConnectionInfo::set_channel(int32_t value) {
  _internal_set_channel(value);
  // @@protoc_insertion_point(field_set:nearby.presence.UwbConnectionInfo.channel)
}

// optional int32 preamble_index = 3;
inline bool UwbConnectionInfo::_internal_has_preamble_index() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool UwbConnectionInfo::has_preamble_index() const {
  return _internal_has_preamble_index();
}
inline void UwbConnectionInfo::clear_preamble_index() {
  preamble_index_ = 0;
  _has_bits_[0] &= ~0x00000020u;
}
inline int32_t UwbConnectionInfo::_internal_preamble_index() const {
  return preamble_index_;
}
inline int32_t UwbConnectionInfo::preamble_index() const {
  // @@protoc_insertion_point(field_get:nearby.presence.UwbConnectionInfo.preamble_index)
  return _internal_preamble_index();
}
inline void UwbConnectionInfo::_internal_set_preamble_index(int32_t value) {
  _has_bits_[0] |= 0x00000020u;
  preamble_index_ = value;
}
inline void UwbConnectionInfo::set_preamble_index(int32_t value) {
  _internal_set_preamble_index(value);
  // @@protoc_insertion_point(field_set:nearby.presence.UwbConnectionInfo.preamble_index)
}

// optional int32 config_id = 4;
inline bool UwbConnectionInfo::_internal_has_config_id() const {
  bool value = (_has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool UwbConnectionInfo::has_config_id() const {
  return _internal_has_config_id();
}
inline void UwbConnectionInfo::clear_config_id() {
  config_id_ = 0;
  _has_bits_[0] &= ~0x00000040u;
}
inline int32_t UwbConnectionInfo::_internal_config_id() const {
  return config_id_;
}
inline int32_t UwbConnectionInfo::config_id() const {
  // @@protoc_insertion_point(field_get:nearby.presence.UwbConnectionInfo.config_id)
  return _internal_config_id();
}
inline void UwbConnectionInfo::_internal_set_config_id(int32_t value) {
  _has_bits_[0] |= 0x00000040u;
  config_id_ = value;
}
inline void UwbConnectionInfo::set_config_id(int32_t value) {
  _internal_set_config_id(value);
  // @@protoc_insertion_point(field_set:nearby.presence.UwbConnectionInfo.config_id)
}

// optional int32 ranging_interval_ms = 5;
inline bool UwbConnectionInfo::_internal_has_ranging_interval_ms() const {
  bool value = (_has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool UwbConnectionInfo::has_ranging_interval_ms() const {
  return _internal_has_ranging_interval_ms();
}
inline void UwbConnectionInfo::clear_ranging_interval_ms() {
  ranging_interval_ms_ = 0;
  _has_bits_[0] &= ~0x00000080u;
}
inline int32_t UwbConnectionInfo::_internal_ranging_interval_ms() const {
  return ranging_interval_ms_;
}
inline int32_t UwbConnectionInfo::ranging_interval_ms() const {
  // @@protoc_insertion_point(field_get:nearby.presence.UwbConnectionInfo.ranging_interval_ms)
  return _internal_ranging_interval_ms();
}
inline void UwbConnectionInfo::_internal_set_ranging_interval_ms(int32_t value) {
  _has_bits_[0] |= 0x00000080u;
  ranging_interval_ms_ = value;
}
inline void UwbConnectionInfo::set_ranging_interval_ms(int32_t value) {
  _internal_set_ranging_interval_ms(value);
  // @@protoc_insertion_point(field_set:nearby.presence.UwbConnectionInfo.ranging_interval_ms)
}

// optional int32 session_id = 6;
inline bool UwbConnectionInfo::_internal_has_session_id() const {
  bool value = (_has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool UwbConnectionInfo::has_session_id() const {
  return _internal_has_session_id();
}
inline void UwbConnectionInfo::clear_session_id() {
  session_id_ = 0;
  _has_bits_[0] &= ~0x00000100u;
}
inline int32_t UwbConnectionInfo::_internal_session_id() const {
  return session_id_;
}
inline int32_t UwbConnectionInfo::session_id() const {
  // @@protoc_insertion_point(field_get:nearby.presence.UwbConnectionInfo.session_id)
  return _internal_session_id();
}
inline void UwbConnectionInfo::_internal_set_session_id(int32_t value) {
  _has_bits_[0] |= 0x00000100u;
  session_id_ = value;
}
inline void UwbConnectionInfo::set_session_id(int32_t value) {
  _internal_set_session_id(value);
  // @@protoc_insertion_point(field_set:nearby.presence.UwbConnectionInfo.session_id)
}

// optional bytes vendor_id = 7;
inline bool UwbConnectionInfo::_internal_has_vendor_id() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool UwbConnectionInfo::has_vendor_id() const {
  return _internal_has_vendor_id();
}
inline void UwbConnectionInfo::clear_vendor_id() {
  vendor_id_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& UwbConnectionInfo::vendor_id() const {
  // @@protoc_insertion_point(field_get:nearby.presence.UwbConnectionInfo.vendor_id)
  return _internal_vendor_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void UwbConnectionInfo::set_vendor_id(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000002u;
 vendor_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:nearby.presence.UwbConnectionInfo.vendor_id)
}
inline std::string* UwbConnectionInfo::mutable_vendor_id() {
  std::string* _s = _internal_mutable_vendor_id();
  // @@protoc_insertion_point(field_mutable:nearby.presence.UwbConnectionInfo.vendor_id)
  return _s;
}
inline const std::string& UwbConnectionInfo::_internal_vendor_id() const {
  return vendor_id_.Get();
}
inline void UwbConnectionInfo::_internal_set_vendor_id(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  vendor_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* UwbConnectionInfo::_internal_mutable_vendor_id() {
  _has_bits_[0] |= 0x00000002u;
  return vendor_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* UwbConnectionInfo::release_vendor_id() {
  // @@protoc_insertion_point(field_release:nearby.presence.UwbConnectionInfo.vendor_id)
  if (!_internal_has_vendor_id()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  auto* p = vendor_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (vendor_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    vendor_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void UwbConnectionInfo::set_allocated_vendor_id(std::string* vendor_id) {
  if (vendor_id != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  vendor_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), vendor_id,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (vendor_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    vendor_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:nearby.presence.UwbConnectionInfo.vendor_id)
}

// optional bytes static_sts_iv = 8;
inline bool UwbConnectionInfo::_internal_has_static_sts_iv() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool UwbConnectionInfo::has_static_sts_iv() const {
  return _internal_has_static_sts_iv();
}
inline void UwbConnectionInfo::clear_static_sts_iv() {
  static_sts_iv_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000004u;
}
inline const std::string& UwbConnectionInfo::static_sts_iv() const {
  // @@protoc_insertion_point(field_get:nearby.presence.UwbConnectionInfo.static_sts_iv)
  return _internal_static_sts_iv();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void UwbConnectionInfo::set_static_sts_iv(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000004u;
 static_sts_iv_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:nearby.presence.UwbConnectionInfo.static_sts_iv)
}
inline std::string* UwbConnectionInfo::mutable_static_sts_iv() {
  std::string* _s = _internal_mutable_static_sts_iv();
  // @@protoc_insertion_point(field_mutable:nearby.presence.UwbConnectionInfo.static_sts_iv)
  return _s;
}
inline const std::string& UwbConnectionInfo::_internal_static_sts_iv() const {
  return static_sts_iv_.Get();
}
inline void UwbConnectionInfo::_internal_set_static_sts_iv(const std::string& value) {
  _has_bits_[0] |= 0x00000004u;
  static_sts_iv_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* UwbConnectionInfo::_internal_mutable_static_sts_iv() {
  _has_bits_[0] |= 0x00000004u;
  return static_sts_iv_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* UwbConnectionInfo::release_static_sts_iv() {
  // @@protoc_insertion_point(field_release:nearby.presence.UwbConnectionInfo.static_sts_iv)
  if (!_internal_has_static_sts_iv()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000004u;
  auto* p = static_sts_iv_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (static_sts_iv_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    static_sts_iv_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void UwbConnectionInfo::set_allocated_static_sts_iv(std::string* static_sts_iv) {
  if (static_sts_iv != nullptr) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  static_sts_iv_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), static_sts_iv,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (static_sts_iv_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    static_sts_iv_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:nearby.presence.UwbConnectionInfo.static_sts_iv)
}

// optional bytes session_key = 9;
inline bool UwbConnectionInfo::_internal_has_session_key() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool UwbConnectionInfo::has_session_key() const {
  return _internal_has_session_key();
}
inline void UwbConnectionInfo::clear_session_key() {
  session_key_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000008u;
}
inline const std::string& UwbConnectionInfo::session_key() const {
  // @@protoc_insertion_point(field_get:nearby.presence.UwbConnectionInfo.session_key)
  return _internal_session_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void UwbConnectionInfo::set_session_key(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000008u;
 session_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:nearby.presence.UwbConnectionInfo.session_key)
}
inline std::string* UwbConnectionInfo::mutable_session_key() {
  std::string* _s = _internal_mutable_session_key();
  // @@protoc_insertion_point(field_mutable:nearby.presence.UwbConnectionInfo.session_key)
  return _s;
}
inline const std::string& UwbConnectionInfo::_internal_session_key() const {
  return session_key_.Get();
}
inline void UwbConnectionInfo::_internal_set_session_key(const std::string& value) {
  _has_bits_[0] |= 0x00000008u;
  session_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* UwbConnectionInfo::_internal_mutable_session_key() {
  _has_bits_[0] |= 0x00000008u;
  return session_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* UwbConnectionInfo::release_session_key() {
  // @@protoc_insertion_point(field_release:nearby.presence.UwbConnectionInfo.session_key)
  if (!_internal_has_session_key()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000008u;
  auto* p = session_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (session_key_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    session_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void UwbConnectionInfo::set_allocated_session_key(std::string* session_key) {
  if (session_key != nullptr) {
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  session_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), session_key,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (session_key_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    session_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:nearby.presence.UwbConnectionInfo.session_key)
}

// optional bool ranging_disabled = 10;
inline bool UwbConnectionInfo::_internal_has_ranging_disabled() const {
  bool value = (_has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool UwbConnectionInfo::has_ranging_disabled() const {
  return _internal_has_ranging_disabled();
}
inline void UwbConnectionInfo::clear_ranging_disabled() {
  ranging_disabled_ = false;
  _has_bits_[0] &= ~0x00000200u;
}
inline bool UwbConnectionInfo::_internal_ranging_disabled() const {
  return ranging_disabled_;
}
inline bool UwbConnectionInfo::ranging_disabled() const {
  // @@protoc_insertion_point(field_get:nearby.presence.UwbConnectionInfo.ranging_disabled)
  return _internal_ranging_disabled();
}
inline void UwbConnectionInfo::_internal_set_ranging_disabled(bool value) {
  _has_bits_[0] |= 0x00000200u;
  ranging_disabled_ = value;
}
inline void UwbConnectionInfo::set_ranging_disabled(bool value) {
  _internal_set_ranging_disabled(value);
  // @@protoc_insertion_point(field_set:nearby.presence.UwbConnectionInfo.ranging_disabled)
}

// -------------------------------------------------------------------

// ControlFrame

// optional .nearby.presence.ControlFrame.ControlType type = 1;
inline bool ControlFrame::_internal_has_type() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ControlFrame::has_type() const {
  return _internal_has_type();
}
inline void ControlFrame::clear_type() {
  type_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::nearby::presence::ControlFrame_ControlType ControlFrame::_internal_type() const {
  return static_cast< ::nearby::presence::ControlFrame_ControlType >(type_);
}
inline ::nearby::presence::ControlFrame_ControlType ControlFrame::type() const {
  // @@protoc_insertion_point(field_get:nearby.presence.ControlFrame.type)
  return _internal_type();
}
inline void ControlFrame::_internal_set_type(::nearby::presence::ControlFrame_ControlType value) {
  assert(::nearby::presence::ControlFrame_ControlType_IsValid(value));
  _has_bits_[0] |= 0x00000001u;
  type_ = value;
}
inline void ControlFrame::set_type(::nearby::presence::ControlFrame_ControlType value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:nearby.presence.ControlFrame.type)
}

// -------------------------------------------------------------------

// PresenceAuthenticationFrame

// optional int32 version = 1;
inline bool PresenceAuthenticationFrame::_internal_has_version() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool PresenceAuthenticationFrame::has_version() const {
  return _internal_has_version();
}
inline void PresenceAuthenticationFrame::clear_version() {
  version_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline int32_t PresenceAuthenticationFrame::_internal_version() const {
  return version_;
}
inline int32_t PresenceAuthenticationFrame::version() const {
  // @@protoc_insertion_point(field_get:nearby.presence.PresenceAuthenticationFrame.version)
  return _internal_version();
}
inline void PresenceAuthenticationFrame::_internal_set_version(int32_t value) {
  _has_bits_[0] |= 0x00000008u;
  version_ = value;
}
inline void PresenceAuthenticationFrame::set_version(int32_t value) {
  _internal_set_version(value);
  // @@protoc_insertion_point(field_set:nearby.presence.PresenceAuthenticationFrame.version)
}

// optional bytes private_key_signature = 2;
inline bool PresenceAuthenticationFrame::_internal_has_private_key_signature() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool PresenceAuthenticationFrame::has_private_key_signature() const {
  return _internal_has_private_key_signature();
}
inline void PresenceAuthenticationFrame::clear_private_key_signature() {
  private_key_signature_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& PresenceAuthenticationFrame::private_key_signature() const {
  // @@protoc_insertion_point(field_get:nearby.presence.PresenceAuthenticationFrame.private_key_signature)
  return _internal_private_key_signature();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PresenceAuthenticationFrame::set_private_key_signature(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 private_key_signature_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:nearby.presence.PresenceAuthenticationFrame.private_key_signature)
}
inline std::string* PresenceAuthenticationFrame::mutable_private_key_signature() {
  std::string* _s = _internal_mutable_private_key_signature();
  // @@protoc_insertion_point(field_mutable:nearby.presence.PresenceAuthenticationFrame.private_key_signature)
  return _s;
}
inline const std::string& PresenceAuthenticationFrame::_internal_private_key_signature() const {
  return private_key_signature_.Get();
}
inline void PresenceAuthenticationFrame::_internal_set_private_key_signature(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  private_key_signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* PresenceAuthenticationFrame::_internal_mutable_private_key_signature() {
  _has_bits_[0] |= 0x00000001u;
  return private_key_signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* PresenceAuthenticationFrame::release_private_key_signature() {
  // @@protoc_insertion_point(field_release:nearby.presence.PresenceAuthenticationFrame.private_key_signature)
  if (!_internal_has_private_key_signature()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  auto* p = private_key_signature_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (private_key_signature_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    private_key_signature_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void PresenceAuthenticationFrame::set_allocated_private_key_signature(std::string* private_key_signature) {
  if (private_key_signature != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  private_key_signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), private_key_signature,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (private_key_signature_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    private_key_signature_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:nearby.presence.PresenceAuthenticationFrame.private_key_signature)
}

// optional bytes shared_credential_id_hash = 3;
inline bool PresenceAuthenticationFrame::_internal_has_shared_credential_id_hash() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool PresenceAuthenticationFrame::has_shared_credential_id_hash() const {
  return _internal_has_shared_credential_id_hash();
}
inline void PresenceAuthenticationFrame::clear_shared_credential_id_hash() {
  shared_credential_id_hash_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& PresenceAuthenticationFrame::shared_credential_id_hash() const {
  // @@protoc_insertion_point(field_get:nearby.presence.PresenceAuthenticationFrame.shared_credential_id_hash)
  return _internal_shared_credential_id_hash();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PresenceAuthenticationFrame::set_shared_credential_id_hash(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000002u;
 shared_credential_id_hash_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:nearby.presence.PresenceAuthenticationFrame.shared_credential_id_hash)
}
inline std::string* PresenceAuthenticationFrame::mutable_shared_credential_id_hash() {
  std::string* _s = _internal_mutable_shared_credential_id_hash();
  // @@protoc_insertion_point(field_mutable:nearby.presence.PresenceAuthenticationFrame.shared_credential_id_hash)
  return _s;
}
inline const std::string& PresenceAuthenticationFrame::_internal_shared_credential_id_hash() const {
  return shared_credential_id_hash_.Get();
}
inline void PresenceAuthenticationFrame::_internal_set_shared_credential_id_hash(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  shared_credential_id_hash_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* PresenceAuthenticationFrame::_internal_mutable_shared_credential_id_hash() {
  _has_bits_[0] |= 0x00000002u;
  return shared_credential_id_hash_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* PresenceAuthenticationFrame::release_shared_credential_id_hash() {
  // @@protoc_insertion_point(field_release:nearby.presence.PresenceAuthenticationFrame.shared_credential_id_hash)
  if (!_internal_has_shared_credential_id_hash()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  auto* p = shared_credential_id_hash_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (shared_credential_id_hash_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    shared_credential_id_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void PresenceAuthenticationFrame::set_allocated_shared_credential_id_hash(std::string* shared_credential_id_hash) {
  if (shared_credential_id_hash != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  shared_credential_id_hash_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), shared_credential_id_hash,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (shared_credential_id_hash_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    shared_credential_id_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:nearby.presence.PresenceAuthenticationFrame.shared_credential_id_hash)
}

// optional bytes credential_id_hash = 4 [deprecated = true];
inline bool PresenceAuthenticationFrame::_internal_has_credential_id_hash() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool PresenceAuthenticationFrame::has_credential_id_hash() const {
  return _internal_has_credential_id_hash();
}
inline void PresenceAuthenticationFrame::clear_credential_id_hash() {
  credential_id_hash_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000004u;
}
inline const std::string& PresenceAuthenticationFrame::credential_id_hash() const {
  // @@protoc_insertion_point(field_get:nearby.presence.PresenceAuthenticationFrame.credential_id_hash)
  return _internal_credential_id_hash();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PresenceAuthenticationFrame::set_credential_id_hash(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000004u;
 credential_id_hash_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:nearby.presence.PresenceAuthenticationFrame.credential_id_hash)
}
inline std::string* PresenceAuthenticationFrame::mutable_credential_id_hash() {
  std::string* _s = _internal_mutable_credential_id_hash();
  // @@protoc_insertion_point(field_mutable:nearby.presence.PresenceAuthenticationFrame.credential_id_hash)
  return _s;
}
inline const std::string& PresenceAuthenticationFrame::_internal_credential_id_hash() const {
  return credential_id_hash_.Get();
}
inline void PresenceAuthenticationFrame::_internal_set_credential_id_hash(const std::string& value) {
  _has_bits_[0] |= 0x00000004u;
  credential_id_hash_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* PresenceAuthenticationFrame::_internal_mutable_credential_id_hash() {
  _has_bits_[0] |= 0x00000004u;
  return credential_id_hash_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* PresenceAuthenticationFrame::release_credential_id_hash() {
  // @@protoc_insertion_point(field_release:nearby.presence.PresenceAuthenticationFrame.credential_id_hash)
  if (!_internal_has_credential_id_hash()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000004u;
  auto* p = credential_id_hash_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (credential_id_hash_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    credential_id_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void PresenceAuthenticationFrame::set_allocated_credential_id_hash(std::string* credential_id_hash) {
  if (credential_id_hash != nullptr) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  credential_id_hash_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), credential_id_hash,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (credential_id_hash_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    credential_id_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:nearby.presence.PresenceAuthenticationFrame.credential_id_hash)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace presence
}  // namespace nearby

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::nearby::presence::PresenceFrame_Version> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::nearby::presence::PresenceFrame_Version>() {
  return ::nearby::presence::PresenceFrame_Version_descriptor();
}
template <> struct is_proto_enum< ::nearby::presence::ControlFrame_ControlType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::nearby::presence::ControlFrame_ControlType>() {
  return ::nearby::presence::ControlFrame_ControlType_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_presence_2fproto_2fpresence_5fframe_2eproto