libsession-util/proto/SessionProtos.pb.h

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

#ifndef GOOGLE_PROTOBUF_INCLUDED_SessionProtos_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_SessionProtos_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#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 3021012 < 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_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/message_lite.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_util.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_SessionProtos_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_SessionProtos_2eproto {
  static const uint32_t offsets[];
};
namespace SessionProtos {
class AttachmentPointer;
struct AttachmentPointerDefaultTypeInternal;
extern AttachmentPointerDefaultTypeInternal _AttachmentPointer_default_instance_;
class CallMessage;
struct CallMessageDefaultTypeInternal;
extern CallMessageDefaultTypeInternal _CallMessage_default_instance_;
class Content;
struct ContentDefaultTypeInternal;
extern ContentDefaultTypeInternal _Content_default_instance_;
class DataExtractionNotification;
struct DataExtractionNotificationDefaultTypeInternal;
extern DataExtractionNotificationDefaultTypeInternal _DataExtractionNotification_default_instance_;
class DataMessage;
struct DataMessageDefaultTypeInternal;
extern DataMessageDefaultTypeInternal _DataMessage_default_instance_;
class DataMessage_OpenGroupInvitation;
struct DataMessage_OpenGroupInvitationDefaultTypeInternal;
extern DataMessage_OpenGroupInvitationDefaultTypeInternal _DataMessage_OpenGroupInvitation_default_instance_;
class DataMessage_Preview;
struct DataMessage_PreviewDefaultTypeInternal;
extern DataMessage_PreviewDefaultTypeInternal _DataMessage_Preview_default_instance_;
class DataMessage_Quote;
struct DataMessage_QuoteDefaultTypeInternal;
extern DataMessage_QuoteDefaultTypeInternal _DataMessage_Quote_default_instance_;
class DataMessage_Quote_QuotedAttachment;
struct DataMessage_Quote_QuotedAttachmentDefaultTypeInternal;
extern DataMessage_Quote_QuotedAttachmentDefaultTypeInternal _DataMessage_Quote_QuotedAttachment_default_instance_;
class DataMessage_Reaction;
struct DataMessage_ReactionDefaultTypeInternal;
extern DataMessage_ReactionDefaultTypeInternal _DataMessage_Reaction_default_instance_;
class Envelope;
struct EnvelopeDefaultTypeInternal;
extern EnvelopeDefaultTypeInternal _Envelope_default_instance_;
class GroupUpdateDeleteMemberContentMessage;
struct GroupUpdateDeleteMemberContentMessageDefaultTypeInternal;
extern GroupUpdateDeleteMemberContentMessageDefaultTypeInternal _GroupUpdateDeleteMemberContentMessage_default_instance_;
class GroupUpdateInfoChangeMessage;
struct GroupUpdateInfoChangeMessageDefaultTypeInternal;
extern GroupUpdateInfoChangeMessageDefaultTypeInternal _GroupUpdateInfoChangeMessage_default_instance_;
class GroupUpdateInviteMessage;
struct GroupUpdateInviteMessageDefaultTypeInternal;
extern GroupUpdateInviteMessageDefaultTypeInternal _GroupUpdateInviteMessage_default_instance_;
class GroupUpdateInviteResponseMessage;
struct GroupUpdateInviteResponseMessageDefaultTypeInternal;
extern GroupUpdateInviteResponseMessageDefaultTypeInternal _GroupUpdateInviteResponseMessage_default_instance_;
class GroupUpdateMemberChangeMessage;
struct GroupUpdateMemberChangeMessageDefaultTypeInternal;
extern GroupUpdateMemberChangeMessageDefaultTypeInternal _GroupUpdateMemberChangeMessage_default_instance_;
class GroupUpdateMemberLeftMessage;
struct GroupUpdateMemberLeftMessageDefaultTypeInternal;
extern GroupUpdateMemberLeftMessageDefaultTypeInternal _GroupUpdateMemberLeftMessage_default_instance_;
class GroupUpdateMemberLeftNotificationMessage;
struct GroupUpdateMemberLeftNotificationMessageDefaultTypeInternal;
extern GroupUpdateMemberLeftNotificationMessageDefaultTypeInternal _GroupUpdateMemberLeftNotificationMessage_default_instance_;
class GroupUpdateMessage;
struct GroupUpdateMessageDefaultTypeInternal;
extern GroupUpdateMessageDefaultTypeInternal _GroupUpdateMessage_default_instance_;
class GroupUpdatePromoteMessage;
struct GroupUpdatePromoteMessageDefaultTypeInternal;
extern GroupUpdatePromoteMessageDefaultTypeInternal _GroupUpdatePromoteMessage_default_instance_;
class KeyPair;
struct KeyPairDefaultTypeInternal;
extern KeyPairDefaultTypeInternal _KeyPair_default_instance_;
class LokiProfile;
struct LokiProfileDefaultTypeInternal;
extern LokiProfileDefaultTypeInternal _LokiProfile_default_instance_;
class MessageRequestResponse;
struct MessageRequestResponseDefaultTypeInternal;
extern MessageRequestResponseDefaultTypeInternal _MessageRequestResponse_default_instance_;
class ProMessage;
struct ProMessageDefaultTypeInternal;
extern ProMessageDefaultTypeInternal _ProMessage_default_instance_;
class ProProof;
struct ProProofDefaultTypeInternal;
extern ProProofDefaultTypeInternal _ProProof_default_instance_;
class ReceiptMessage;
struct ReceiptMessageDefaultTypeInternal;
extern ReceiptMessageDefaultTypeInternal _ReceiptMessage_default_instance_;
class SharedConfigMessage;
struct SharedConfigMessageDefaultTypeInternal;
extern SharedConfigMessageDefaultTypeInternal _SharedConfigMessage_default_instance_;
class TypingMessage;
struct TypingMessageDefaultTypeInternal;
extern TypingMessageDefaultTypeInternal _TypingMessage_default_instance_;
class UnsendRequest;
struct UnsendRequestDefaultTypeInternal;
extern UnsendRequestDefaultTypeInternal _UnsendRequest_default_instance_;
}  // namespace SessionProtos
PROTOBUF_NAMESPACE_OPEN
template<> ::SessionProtos::AttachmentPointer* Arena::CreateMaybeMessage<::SessionProtos::AttachmentPointer>(Arena*);
template<> ::SessionProtos::CallMessage* Arena::CreateMaybeMessage<::SessionProtos::CallMessage>(Arena*);
template<> ::SessionProtos::Content* Arena::CreateMaybeMessage<::SessionProtos::Content>(Arena*);
template<> ::SessionProtos::DataExtractionNotification* Arena::CreateMaybeMessage<::SessionProtos::DataExtractionNotification>(Arena*);
template<> ::SessionProtos::DataMessage* Arena::CreateMaybeMessage<::SessionProtos::DataMessage>(Arena*);
template<> ::SessionProtos::DataMessage_OpenGroupInvitation* Arena::CreateMaybeMessage<::SessionProtos::DataMessage_OpenGroupInvitation>(Arena*);
template<> ::SessionProtos::DataMessage_Preview* Arena::CreateMaybeMessage<::SessionProtos::DataMessage_Preview>(Arena*);
template<> ::SessionProtos::DataMessage_Quote* Arena::CreateMaybeMessage<::SessionProtos::DataMessage_Quote>(Arena*);
template<> ::SessionProtos::DataMessage_Quote_QuotedAttachment* Arena::CreateMaybeMessage<::SessionProtos::DataMessage_Quote_QuotedAttachment>(Arena*);
template<> ::SessionProtos::DataMessage_Reaction* Arena::CreateMaybeMessage<::SessionProtos::DataMessage_Reaction>(Arena*);
template<> ::SessionProtos::Envelope* Arena::CreateMaybeMessage<::SessionProtos::Envelope>(Arena*);
template<> ::SessionProtos::GroupUpdateDeleteMemberContentMessage* Arena::CreateMaybeMessage<::SessionProtos::GroupUpdateDeleteMemberContentMessage>(Arena*);
template<> ::SessionProtos::GroupUpdateInfoChangeMessage* Arena::CreateMaybeMessage<::SessionProtos::GroupUpdateInfoChangeMessage>(Arena*);
template<> ::SessionProtos::GroupUpdateInviteMessage* Arena::CreateMaybeMessage<::SessionProtos::GroupUpdateInviteMessage>(Arena*);
template<> ::SessionProtos::GroupUpdateInviteResponseMessage* Arena::CreateMaybeMessage<::SessionProtos::GroupUpdateInviteResponseMessage>(Arena*);
template<> ::SessionProtos::GroupUpdateMemberChangeMessage* Arena::CreateMaybeMessage<::SessionProtos::GroupUpdateMemberChangeMessage>(Arena*);
template<> ::SessionProtos::GroupUpdateMemberLeftMessage* Arena::CreateMaybeMessage<::SessionProtos::GroupUpdateMemberLeftMessage>(Arena*);
template<> ::SessionProtos::GroupUpdateMemberLeftNotificationMessage* Arena::CreateMaybeMessage<::SessionProtos::GroupUpdateMemberLeftNotificationMessage>(Arena*);
template<> ::SessionProtos::GroupUpdateMessage* Arena::CreateMaybeMessage<::SessionProtos::GroupUpdateMessage>(Arena*);
template<> ::SessionProtos::GroupUpdatePromoteMessage* Arena::CreateMaybeMessage<::SessionProtos::GroupUpdatePromoteMessage>(Arena*);
template<> ::SessionProtos::KeyPair* Arena::CreateMaybeMessage<::SessionProtos::KeyPair>(Arena*);
template<> ::SessionProtos::LokiProfile* Arena::CreateMaybeMessage<::SessionProtos::LokiProfile>(Arena*);
template<> ::SessionProtos::MessageRequestResponse* Arena::CreateMaybeMessage<::SessionProtos::MessageRequestResponse>(Arena*);
template<> ::SessionProtos::ProMessage* Arena::CreateMaybeMessage<::SessionProtos::ProMessage>(Arena*);
template<> ::SessionProtos::ProProof* Arena::CreateMaybeMessage<::SessionProtos::ProProof>(Arena*);
template<> ::SessionProtos::ReceiptMessage* Arena::CreateMaybeMessage<::SessionProtos::ReceiptMessage>(Arena*);
template<> ::SessionProtos::SharedConfigMessage* Arena::CreateMaybeMessage<::SessionProtos::SharedConfigMessage>(Arena*);
template<> ::SessionProtos::TypingMessage* Arena::CreateMaybeMessage<::SessionProtos::TypingMessage>(Arena*);
template<> ::SessionProtos::UnsendRequest* Arena::CreateMaybeMessage<::SessionProtos::UnsendRequest>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace SessionProtos {

enum Envelope_Type : int {
  Envelope_Type_SESSION_MESSAGE = 6,
  Envelope_Type_CLOSED_GROUP_MESSAGE = 7
};
bool Envelope_Type_IsValid(int value);
constexpr Envelope_Type Envelope_Type_Type_MIN = Envelope_Type_SESSION_MESSAGE;
constexpr Envelope_Type Envelope_Type_Type_MAX = Envelope_Type_CLOSED_GROUP_MESSAGE;
constexpr int Envelope_Type_Type_ARRAYSIZE = Envelope_Type_Type_MAX + 1;

const std::string& Envelope_Type_Name(Envelope_Type value);
template<typename T>
inline const std::string& Envelope_Type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Envelope_Type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Envelope_Type_Name.");
  return Envelope_Type_Name(static_cast<Envelope_Type>(enum_t_value));
}
bool Envelope_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Envelope_Type* value);
enum TypingMessage_Action : int {
  TypingMessage_Action_STARTED = 0,
  TypingMessage_Action_STOPPED = 1
};
bool TypingMessage_Action_IsValid(int value);
constexpr TypingMessage_Action TypingMessage_Action_Action_MIN = TypingMessage_Action_STARTED;
constexpr TypingMessage_Action TypingMessage_Action_Action_MAX = TypingMessage_Action_STOPPED;
constexpr int TypingMessage_Action_Action_ARRAYSIZE = TypingMessage_Action_Action_MAX + 1;

const std::string& TypingMessage_Action_Name(TypingMessage_Action value);
template<typename T>
inline const std::string& TypingMessage_Action_Name(T enum_t_value) {
  static_assert(::std::is_same<T, TypingMessage_Action>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function TypingMessage_Action_Name.");
  return TypingMessage_Action_Name(static_cast<TypingMessage_Action>(enum_t_value));
}
bool TypingMessage_Action_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TypingMessage_Action* value);
enum Content_ExpirationType : int {
  Content_ExpirationType_UNKNOWN = 0,
  Content_ExpirationType_DELETE_AFTER_READ = 1,
  Content_ExpirationType_DELETE_AFTER_SEND = 2
};
bool Content_ExpirationType_IsValid(int value);
constexpr Content_ExpirationType Content_ExpirationType_ExpirationType_MIN = Content_ExpirationType_UNKNOWN;
constexpr Content_ExpirationType Content_ExpirationType_ExpirationType_MAX = Content_ExpirationType_DELETE_AFTER_SEND;
constexpr int Content_ExpirationType_ExpirationType_ARRAYSIZE = Content_ExpirationType_ExpirationType_MAX + 1;

const std::string& Content_ExpirationType_Name(Content_ExpirationType value);
template<typename T>
inline const std::string& Content_ExpirationType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Content_ExpirationType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Content_ExpirationType_Name.");
  return Content_ExpirationType_Name(static_cast<Content_ExpirationType>(enum_t_value));
}
bool Content_ExpirationType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Content_ExpirationType* value);
enum CallMessage_Type : int {
  CallMessage_Type_PRE_OFFER = 6,
  CallMessage_Type_OFFER = 1,
  CallMessage_Type_ANSWER = 2,
  CallMessage_Type_PROVISIONAL_ANSWER = 3,
  CallMessage_Type_ICE_CANDIDATES = 4,
  CallMessage_Type_END_CALL = 5
};
bool CallMessage_Type_IsValid(int value);
constexpr CallMessage_Type CallMessage_Type_Type_MIN = CallMessage_Type_OFFER;
constexpr CallMessage_Type CallMessage_Type_Type_MAX = CallMessage_Type_PRE_OFFER;
constexpr int CallMessage_Type_Type_ARRAYSIZE = CallMessage_Type_Type_MAX + 1;

const std::string& CallMessage_Type_Name(CallMessage_Type value);
template<typename T>
inline const std::string& CallMessage_Type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, CallMessage_Type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function CallMessage_Type_Name.");
  return CallMessage_Type_Name(static_cast<CallMessage_Type>(enum_t_value));
}
bool CallMessage_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CallMessage_Type* value);
enum DataExtractionNotification_Type : int {
  DataExtractionNotification_Type_SCREENSHOT = 1,
  DataExtractionNotification_Type_MEDIA_SAVED = 2
};
bool DataExtractionNotification_Type_IsValid(int value);
constexpr DataExtractionNotification_Type DataExtractionNotification_Type_Type_MIN = DataExtractionNotification_Type_SCREENSHOT;
constexpr DataExtractionNotification_Type DataExtractionNotification_Type_Type_MAX = DataExtractionNotification_Type_MEDIA_SAVED;
constexpr int DataExtractionNotification_Type_Type_ARRAYSIZE = DataExtractionNotification_Type_Type_MAX + 1;

const std::string& DataExtractionNotification_Type_Name(DataExtractionNotification_Type value);
template<typename T>
inline const std::string& DataExtractionNotification_Type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DataExtractionNotification_Type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DataExtractionNotification_Type_Name.");
  return DataExtractionNotification_Type_Name(static_cast<DataExtractionNotification_Type>(enum_t_value));
}
bool DataExtractionNotification_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DataExtractionNotification_Type* value);
enum DataMessage_Quote_QuotedAttachment_Flags : int {
  DataMessage_Quote_QuotedAttachment_Flags_VOICE_MESSAGE = 1
};
bool DataMessage_Quote_QuotedAttachment_Flags_IsValid(int value);
constexpr DataMessage_Quote_QuotedAttachment_Flags DataMessage_Quote_QuotedAttachment_Flags_Flags_MIN = DataMessage_Quote_QuotedAttachment_Flags_VOICE_MESSAGE;
constexpr DataMessage_Quote_QuotedAttachment_Flags DataMessage_Quote_QuotedAttachment_Flags_Flags_MAX = DataMessage_Quote_QuotedAttachment_Flags_VOICE_MESSAGE;
constexpr int DataMessage_Quote_QuotedAttachment_Flags_Flags_ARRAYSIZE = DataMessage_Quote_QuotedAttachment_Flags_Flags_MAX + 1;

const std::string& DataMessage_Quote_QuotedAttachment_Flags_Name(DataMessage_Quote_QuotedAttachment_Flags value);
template<typename T>
inline const std::string& DataMessage_Quote_QuotedAttachment_Flags_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DataMessage_Quote_QuotedAttachment_Flags>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DataMessage_Quote_QuotedAttachment_Flags_Name.");
  return DataMessage_Quote_QuotedAttachment_Flags_Name(static_cast<DataMessage_Quote_QuotedAttachment_Flags>(enum_t_value));
}
bool DataMessage_Quote_QuotedAttachment_Flags_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DataMessage_Quote_QuotedAttachment_Flags* value);
enum DataMessage_Reaction_Action : int {
  DataMessage_Reaction_Action_REACT = 0,
  DataMessage_Reaction_Action_REMOVE = 1
};
bool DataMessage_Reaction_Action_IsValid(int value);
constexpr DataMessage_Reaction_Action DataMessage_Reaction_Action_Action_MIN = DataMessage_Reaction_Action_REACT;
constexpr DataMessage_Reaction_Action DataMessage_Reaction_Action_Action_MAX = DataMessage_Reaction_Action_REMOVE;
constexpr int DataMessage_Reaction_Action_Action_ARRAYSIZE = DataMessage_Reaction_Action_Action_MAX + 1;

const std::string& DataMessage_Reaction_Action_Name(DataMessage_Reaction_Action value);
template<typename T>
inline const std::string& DataMessage_Reaction_Action_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DataMessage_Reaction_Action>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DataMessage_Reaction_Action_Name.");
  return DataMessage_Reaction_Action_Name(static_cast<DataMessage_Reaction_Action>(enum_t_value));
}
bool DataMessage_Reaction_Action_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DataMessage_Reaction_Action* value);
enum DataMessage_Flags : int {
  DataMessage_Flags_EXPIRATION_TIMER_UPDATE = 2
};
bool DataMessage_Flags_IsValid(int value);
constexpr DataMessage_Flags DataMessage_Flags_Flags_MIN = DataMessage_Flags_EXPIRATION_TIMER_UPDATE;
constexpr DataMessage_Flags DataMessage_Flags_Flags_MAX = DataMessage_Flags_EXPIRATION_TIMER_UPDATE;
constexpr int DataMessage_Flags_Flags_ARRAYSIZE = DataMessage_Flags_Flags_MAX + 1;

const std::string& DataMessage_Flags_Name(DataMessage_Flags value);
template<typename T>
inline const std::string& DataMessage_Flags_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DataMessage_Flags>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DataMessage_Flags_Name.");
  return DataMessage_Flags_Name(static_cast<DataMessage_Flags>(enum_t_value));
}
bool DataMessage_Flags_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DataMessage_Flags* value);
enum ReceiptMessage_Type : int {
  ReceiptMessage_Type_DELIVERY = 0,
  ReceiptMessage_Type_READ = 1
};
bool ReceiptMessage_Type_IsValid(int value);
constexpr ReceiptMessage_Type ReceiptMessage_Type_Type_MIN = ReceiptMessage_Type_DELIVERY;
constexpr ReceiptMessage_Type ReceiptMessage_Type_Type_MAX = ReceiptMessage_Type_READ;
constexpr int ReceiptMessage_Type_Type_ARRAYSIZE = ReceiptMessage_Type_Type_MAX + 1;

const std::string& ReceiptMessage_Type_Name(ReceiptMessage_Type value);
template<typename T>
inline const std::string& ReceiptMessage_Type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ReceiptMessage_Type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ReceiptMessage_Type_Name.");
  return ReceiptMessage_Type_Name(static_cast<ReceiptMessage_Type>(enum_t_value));
}
bool ReceiptMessage_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ReceiptMessage_Type* value);
enum AttachmentPointer_Flags : int {
  AttachmentPointer_Flags_VOICE_MESSAGE = 1
};
bool AttachmentPointer_Flags_IsValid(int value);
constexpr AttachmentPointer_Flags AttachmentPointer_Flags_Flags_MIN = AttachmentPointer_Flags_VOICE_MESSAGE;
constexpr AttachmentPointer_Flags AttachmentPointer_Flags_Flags_MAX = AttachmentPointer_Flags_VOICE_MESSAGE;
constexpr int AttachmentPointer_Flags_Flags_ARRAYSIZE = AttachmentPointer_Flags_Flags_MAX + 1;

const std::string& AttachmentPointer_Flags_Name(AttachmentPointer_Flags value);
template<typename T>
inline const std::string& AttachmentPointer_Flags_Name(T enum_t_value) {
  static_assert(::std::is_same<T, AttachmentPointer_Flags>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function AttachmentPointer_Flags_Name.");
  return AttachmentPointer_Flags_Name(static_cast<AttachmentPointer_Flags>(enum_t_value));
}
bool AttachmentPointer_Flags_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AttachmentPointer_Flags* value);
enum SharedConfigMessage_Kind : int {
  SharedConfigMessage_Kind_USER_PROFILE = 1,
  SharedConfigMessage_Kind_CONTACTS = 2,
  SharedConfigMessage_Kind_CONVO_INFO_VOLATILE = 3,
  SharedConfigMessage_Kind_USER_GROUPS = 4
};
bool SharedConfigMessage_Kind_IsValid(int value);
constexpr SharedConfigMessage_Kind SharedConfigMessage_Kind_Kind_MIN = SharedConfigMessage_Kind_USER_PROFILE;
constexpr SharedConfigMessage_Kind SharedConfigMessage_Kind_Kind_MAX = SharedConfigMessage_Kind_USER_GROUPS;
constexpr int SharedConfigMessage_Kind_Kind_ARRAYSIZE = SharedConfigMessage_Kind_Kind_MAX + 1;

const std::string& SharedConfigMessage_Kind_Name(SharedConfigMessage_Kind value);
template<typename T>
inline const std::string& SharedConfigMessage_Kind_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SharedConfigMessage_Kind>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SharedConfigMessage_Kind_Name.");
  return SharedConfigMessage_Kind_Name(static_cast<SharedConfigMessage_Kind>(enum_t_value));
}
bool SharedConfigMessage_Kind_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SharedConfigMessage_Kind* value);
enum GroupUpdateInfoChangeMessage_Type : int {
  GroupUpdateInfoChangeMessage_Type_NAME = 1,
  GroupUpdateInfoChangeMessage_Type_AVATAR = 2,
  GroupUpdateInfoChangeMessage_Type_DISAPPEARING_MESSAGES = 3
};
bool GroupUpdateInfoChangeMessage_Type_IsValid(int value);
constexpr GroupUpdateInfoChangeMessage_Type GroupUpdateInfoChangeMessage_Type_Type_MIN = GroupUpdateInfoChangeMessage_Type_NAME;
constexpr GroupUpdateInfoChangeMessage_Type GroupUpdateInfoChangeMessage_Type_Type_MAX = GroupUpdateInfoChangeMessage_Type_DISAPPEARING_MESSAGES;
constexpr int GroupUpdateInfoChangeMessage_Type_Type_ARRAYSIZE = GroupUpdateInfoChangeMessage_Type_Type_MAX + 1;

const std::string& GroupUpdateInfoChangeMessage_Type_Name(GroupUpdateInfoChangeMessage_Type value);
template<typename T>
inline const std::string& GroupUpdateInfoChangeMessage_Type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, GroupUpdateInfoChangeMessage_Type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function GroupUpdateInfoChangeMessage_Type_Name.");
  return GroupUpdateInfoChangeMessage_Type_Name(static_cast<GroupUpdateInfoChangeMessage_Type>(enum_t_value));
}
bool GroupUpdateInfoChangeMessage_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, GroupUpdateInfoChangeMessage_Type* value);
enum GroupUpdateMemberChangeMessage_Type : int {
  GroupUpdateMemberChangeMessage_Type_ADDED = 1,
  GroupUpdateMemberChangeMessage_Type_REMOVED = 2,
  GroupUpdateMemberChangeMessage_Type_PROMOTED = 3
};
bool GroupUpdateMemberChangeMessage_Type_IsValid(int value);
constexpr GroupUpdateMemberChangeMessage_Type GroupUpdateMemberChangeMessage_Type_Type_MIN = GroupUpdateMemberChangeMessage_Type_ADDED;
constexpr GroupUpdateMemberChangeMessage_Type GroupUpdateMemberChangeMessage_Type_Type_MAX = GroupUpdateMemberChangeMessage_Type_PROMOTED;
constexpr int GroupUpdateMemberChangeMessage_Type_Type_ARRAYSIZE = GroupUpdateMemberChangeMessage_Type_Type_MAX + 1;

const std::string& GroupUpdateMemberChangeMessage_Type_Name(GroupUpdateMemberChangeMessage_Type value);
template<typename T>
inline const std::string& GroupUpdateMemberChangeMessage_Type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, GroupUpdateMemberChangeMessage_Type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function GroupUpdateMemberChangeMessage_Type_Name.");
  return GroupUpdateMemberChangeMessage_Type_Name(static_cast<GroupUpdateMemberChangeMessage_Type>(enum_t_value));
}
bool GroupUpdateMemberChangeMessage_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, GroupUpdateMemberChangeMessage_Type* value);
// ===================================================================

class Envelope final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:SessionProtos.Envelope) */ {
 public:
  inline Envelope() : Envelope(nullptr) {}
  ~Envelope() override;
  explicit PROTOBUF_CONSTEXPR Envelope(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline Envelope& operator=(const Envelope& from) {
    CopyFrom(from);
    return *this;
  }
  inline Envelope& operator=(Envelope&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const Envelope& default_instance() {
    return *internal_default_instance();
  }
  static inline const Envelope* internal_default_instance() {
    return reinterpret_cast<const Envelope*>(
               &_Envelope_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

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

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

  Envelope* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Envelope>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const Envelope& from);
  void MergeFrom(const Envelope& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Envelope* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SessionProtos.Envelope";
  }
  protected:
  explicit Envelope(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

  typedef Envelope_Type Type;
  static constexpr Type SESSION_MESSAGE =
    Envelope_Type_SESSION_MESSAGE;
  static constexpr Type CLOSED_GROUP_MESSAGE =
    Envelope_Type_CLOSED_GROUP_MESSAGE;
  static inline bool Type_IsValid(int value) {
    return Envelope_Type_IsValid(value);
  }
  static constexpr Type Type_MIN =
    Envelope_Type_Type_MIN;
  static constexpr Type Type_MAX =
    Envelope_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE =
    Envelope_Type_Type_ARRAYSIZE;
  template<typename T>
  static inline const std::string& Type_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Type>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Type_Name.");
    return Envelope_Type_Name(enum_t_value);
  }
  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Type* value) {
    return Envelope_Type_Parse(name, value);
  }

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

  enum : int {
    kSourceFieldNumber = 2,
    kContentFieldNumber = 8,
    kProSigFieldNumber = 11,
    kTimestampFieldNumber = 5,
    kServerTimestampFieldNumber = 10,
    kSourceDeviceFieldNumber = 7,
    kTypeFieldNumber = 1,
  };
  // optional string source = 2;
  bool has_source() const;
  private:
  bool _internal_has_source() const;
  public:
  void clear_source();
  const std::string& source() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_source(ArgT0&& arg0, ArgT... args);
  std::string* mutable_source();
  PROTOBUF_NODISCARD std::string* release_source();
  void set_allocated_source(std::string* source);
  private:
  const std::string& _internal_source() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_source(const std::string& value);
  std::string* _internal_mutable_source();
  public:

  // optional bytes content = 8;
  bool has_content() const;
  private:
  bool _internal_has_content() const;
  public:
  void clear_content();
  const std::string& content() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_content(ArgT0&& arg0, ArgT... args);
  std::string* mutable_content();
  PROTOBUF_NODISCARD std::string* release_content();
  void set_allocated_content(std::string* content);
  private:
  const std::string& _internal_content() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_content(const std::string& value);
  std::string* _internal_mutable_content();
  public:

  // optional bytes proSig = 11;
  bool has_prosig() const;
  private:
  bool _internal_has_prosig() const;
  public:
  void clear_prosig();
  const std::string& prosig() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_prosig(ArgT0&& arg0, ArgT... args);
  std::string* mutable_prosig();
  PROTOBUF_NODISCARD std::string* release_prosig();
  void set_allocated_prosig(std::string* prosig);
  private:
  const std::string& _internal_prosig() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_prosig(const std::string& value);
  std::string* _internal_mutable_prosig();
  public:

  // required uint64 timestamp = 5;
  bool has_timestamp() const;
  private:
  bool _internal_has_timestamp() const;
  public:
  void clear_timestamp();
  uint64_t timestamp() const;
  void set_timestamp(uint64_t value);
  private:
  uint64_t _internal_timestamp() const;
  void _internal_set_timestamp(uint64_t value);
  public:

  // optional uint64 serverTimestamp = 10;
  bool has_servertimestamp() const;
  private:
  bool _internal_has_servertimestamp() const;
  public:
  void clear_servertimestamp();
  uint64_t servertimestamp() const;
  void set_servertimestamp(uint64_t value);
  private:
  uint64_t _internal_servertimestamp() const;
  void _internal_set_servertimestamp(uint64_t value);
  public:

  // optional uint32 sourceDevice = 7;
  bool has_sourcedevice() const;
  private:
  bool _internal_has_sourcedevice() const;
  public:
  void clear_sourcedevice();
  uint32_t sourcedevice() const;
  void set_sourcedevice(uint32_t value);
  private:
  uint32_t _internal_sourcedevice() const;
  void _internal_set_sourcedevice(uint32_t value);
  public:

  // required .SessionProtos.Envelope.Type type = 1;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::SessionProtos::Envelope_Type type() const;
  void set_type(::SessionProtos::Envelope_Type value);
  private:
  ::SessionProtos::Envelope_Type _internal_type() const;
  void _internal_set_type(::SessionProtos::Envelope_Type value);
  public:

  // @@protoc_insertion_point(class_scope:SessionProtos.Envelope)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr content_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr prosig_;
    uint64_t timestamp_;
    uint64_t servertimestamp_;
    uint32_t sourcedevice_;
    int type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_SessionProtos_2eproto;
};
// -------------------------------------------------------------------

class TypingMessage final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:SessionProtos.TypingMessage) */ {
 public:
  inline TypingMessage() : TypingMessage(nullptr) {}
  ~TypingMessage() override;
  explicit PROTOBUF_CONSTEXPR TypingMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline TypingMessage& operator=(const TypingMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline TypingMessage& operator=(TypingMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

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

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

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

  TypingMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TypingMessage>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const TypingMessage& from);
  void MergeFrom(const TypingMessage& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(TypingMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SessionProtos.TypingMessage";
  }
  protected:
  explicit TypingMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

  typedef TypingMessage_Action Action;
  static constexpr Action STARTED =
    TypingMessage_Action_STARTED;
  static constexpr Action STOPPED =
    TypingMessage_Action_STOPPED;
  static inline bool Action_IsValid(int value) {
    return TypingMessage_Action_IsValid(value);
  }
  static constexpr Action Action_MIN =
    TypingMessage_Action_Action_MIN;
  static constexpr Action Action_MAX =
    TypingMessage_Action_Action_MAX;
  static constexpr int Action_ARRAYSIZE =
    TypingMessage_Action_Action_ARRAYSIZE;
  template<typename T>
  static inline const std::string& Action_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Action>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Action_Name.");
    return TypingMessage_Action_Name(enum_t_value);
  }
  static inline bool Action_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Action* value) {
    return TypingMessage_Action_Parse(name, value);
  }

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

  enum : int {
    kTimestampFieldNumber = 1,
    kActionFieldNumber = 2,
  };
  // required uint64 timestamp = 1;
  bool has_timestamp() const;
  private:
  bool _internal_has_timestamp() const;
  public:
  void clear_timestamp();
  uint64_t timestamp() const;
  void set_timestamp(uint64_t value);
  private:
  uint64_t _internal_timestamp() const;
  void _internal_set_timestamp(uint64_t value);
  public:

  // required .SessionProtos.TypingMessage.Action action = 2;
  bool has_action() const;
  private:
  bool _internal_has_action() const;
  public:
  void clear_action();
  ::SessionProtos::TypingMessage_Action action() const;
  void set_action(::SessionProtos::TypingMessage_Action value);
  private:
  ::SessionProtos::TypingMessage_Action _internal_action() const;
  void _internal_set_action(::SessionProtos::TypingMessage_Action value);
  public:

  // @@protoc_insertion_point(class_scope:SessionProtos.TypingMessage)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint64_t timestamp_;
    int action_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_SessionProtos_2eproto;
};
// -------------------------------------------------------------------

class UnsendRequest final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:SessionProtos.UnsendRequest) */ {
 public:
  inline UnsendRequest() : UnsendRequest(nullptr) {}
  ~UnsendRequest() override;
  explicit PROTOBUF_CONSTEXPR UnsendRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline UnsendRequest& operator=(const UnsendRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline UnsendRequest& operator=(UnsendRequest&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const UnsendRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const UnsendRequest* internal_default_instance() {
    return reinterpret_cast<const UnsendRequest*>(
               &_UnsendRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

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

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

  UnsendRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<UnsendRequest>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const UnsendRequest& from);
  void MergeFrom(const UnsendRequest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(UnsendRequest* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SessionProtos.UnsendRequest";
  }
  protected:
  explicit UnsendRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kAuthorFieldNumber = 2,
    kTimestampFieldNumber = 1,
  };
  // required string author = 2;
  bool has_author() const;
  private:
  bool _internal_has_author() const;
  public:
  void clear_author();
  const std::string& author() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_author(ArgT0&& arg0, ArgT... args);
  std::string* mutable_author();
  PROTOBUF_NODISCARD std::string* release_author();
  void set_allocated_author(std::string* author);
  private:
  const std::string& _internal_author() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_author(const std::string& value);
  std::string* _internal_mutable_author();
  public:

  // required uint64 timestamp = 1;
  bool has_timestamp() const;
  private:
  bool _internal_has_timestamp() const;
  public:
  void clear_timestamp();
  uint64_t timestamp() const;
  void set_timestamp(uint64_t value);
  private:
  uint64_t _internal_timestamp() const;
  void _internal_set_timestamp(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:SessionProtos.UnsendRequest)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr author_;
    uint64_t timestamp_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_SessionProtos_2eproto;
};
// -------------------------------------------------------------------

class MessageRequestResponse final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:SessionProtos.MessageRequestResponse) */ {
 public:
  inline MessageRequestResponse() : MessageRequestResponse(nullptr) {}
  ~MessageRequestResponse() override;
  explicit PROTOBUF_CONSTEXPR MessageRequestResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline MessageRequestResponse& operator=(const MessageRequestResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline MessageRequestResponse& operator=(MessageRequestResponse&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const MessageRequestResponse& default_instance() {
    return *internal_default_instance();
  }
  static inline const MessageRequestResponse* internal_default_instance() {
    return reinterpret_cast<const MessageRequestResponse*>(
               &_MessageRequestResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

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

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

  MessageRequestResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MessageRequestResponse>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const MessageRequestResponse& from);
  void MergeFrom(const MessageRequestResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(MessageRequestResponse* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SessionProtos.MessageRequestResponse";
  }
  protected:
  explicit MessageRequestResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kProfileKeyFieldNumber = 2,
    kProfileFieldNumber = 3,
    kIsApprovedFieldNumber = 1,
  };
  // optional bytes profileKey = 2;
  bool has_profilekey() const;
  private:
  bool _internal_has_profilekey() const;
  public:
  void clear_profilekey();
  const std::string& profilekey() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_profilekey(ArgT0&& arg0, ArgT... args);
  std::string* mutable_profilekey();
  PROTOBUF_NODISCARD std::string* release_profilekey();
  void set_allocated_profilekey(std::string* profilekey);
  private:
  const std::string& _internal_profilekey() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_profilekey(const std::string& value);
  std::string* _internal_mutable_profilekey();
  public:

  // optional .SessionProtos.LokiProfile profile = 3;
  bool has_profile() const;
  private:
  bool _internal_has_profile() const;
  public:
  void clear_profile();
  const ::SessionProtos::LokiProfile& profile() const;
  PROTOBUF_NODISCARD ::SessionProtos::LokiProfile* release_profile();
  ::SessionProtos::LokiProfile* mutable_profile();
  void set_allocated_profile(::SessionProtos::LokiProfile* profile);
  private:
  const ::SessionProtos::LokiProfile& _internal_profile() const;
  ::SessionProtos::LokiProfile* _internal_mutable_profile();
  public:
  void unsafe_arena_set_allocated_profile(
      ::SessionProtos::LokiProfile* profile);
  ::SessionProtos::LokiProfile* unsafe_arena_release_profile();

  // required bool isApproved = 1;
  bool has_isapproved() const;
  private:
  bool _internal_has_isapproved() const;
  public:
  void clear_isapproved();
  bool isapproved() const;
  void set_isapproved(bool value);
  private:
  bool _internal_isapproved() const;
  void _internal_set_isapproved(bool value);
  public:

  // @@protoc_insertion_point(class_scope:SessionProtos.MessageRequestResponse)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr profilekey_;
    ::SessionProtos::LokiProfile* profile_;
    bool isapproved_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_SessionProtos_2eproto;
};
// -------------------------------------------------------------------

class Content final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:SessionProtos.Content) */ {
 public:
  inline Content() : Content(nullptr) {}
  ~Content() override;
  explicit PROTOBUF_CONSTEXPR Content(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline Content& operator=(const Content& from) {
    CopyFrom(from);
    return *this;
  }
  inline Content& operator=(Content&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const Content& default_instance() {
    return *internal_default_instance();
  }
  static inline const Content* internal_default_instance() {
    return reinterpret_cast<const Content*>(
               &_Content_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

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

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

  Content* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Content>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const Content& from);
  void MergeFrom(const Content& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Content* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SessionProtos.Content";
  }
  protected:
  explicit Content(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

  typedef Content_ExpirationType ExpirationType;
  static constexpr ExpirationType UNKNOWN =
    Content_ExpirationType_UNKNOWN;
  static constexpr ExpirationType DELETE_AFTER_READ =
    Content_ExpirationType_DELETE_AFTER_READ;
  static constexpr ExpirationType DELETE_AFTER_SEND =
    Content_ExpirationType_DELETE_AFTER_SEND;
  static inline bool ExpirationType_IsValid(int value) {
    return Content_ExpirationType_IsValid(value);
  }
  static constexpr ExpirationType ExpirationType_MIN =
    Content_ExpirationType_ExpirationType_MIN;
  static constexpr ExpirationType ExpirationType_MAX =
    Content_ExpirationType_ExpirationType_MAX;
  static constexpr int ExpirationType_ARRAYSIZE =
    Content_ExpirationType_ExpirationType_ARRAYSIZE;
  template<typename T>
  static inline const std::string& ExpirationType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ExpirationType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ExpirationType_Name.");
    return Content_ExpirationType_Name(enum_t_value);
  }
  static inline bool ExpirationType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      ExpirationType* value) {
    return Content_ExpirationType_Parse(name, value);
  }

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

  enum : int {
    kProSigForCommunityMessageOnlyFieldNumber = 17,
    kDataMessageFieldNumber = 1,
    kCallMessageFieldNumber = 3,
    kReceiptMessageFieldNumber = 5,
    kTypingMessageFieldNumber = 6,
    kDataExtractionNotificationFieldNumber = 8,
    kUnsendRequestFieldNumber = 9,
    kMessageRequestResponseFieldNumber = 10,
    kSharedConfigMessageFieldNumber = 11,
    kProMessageFieldNumber = 16,
    kExpirationTypeFieldNumber = 12,
    kExpirationTimerFieldNumber = 13,
    kSigTimestampFieldNumber = 15,
  };
  // optional bytes proSigForCommunityMessageOnly = 17;
  bool has_prosigforcommunitymessageonly() const;
  private:
  bool _internal_has_prosigforcommunitymessageonly() const;
  public:
  void clear_prosigforcommunitymessageonly();
  const std::string& prosigforcommunitymessageonly() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_prosigforcommunitymessageonly(ArgT0&& arg0, ArgT... args);
  std::string* mutable_prosigforcommunitymessageonly();
  PROTOBUF_NODISCARD std::string* release_prosigforcommunitymessageonly();
  void set_allocated_prosigforcommunitymessageonly(std::string* prosigforcommunitymessageonly);
  private:
  const std::string& _internal_prosigforcommunitymessageonly() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_prosigforcommunitymessageonly(const std::string& value);
  std::string* _internal_mutable_prosigforcommunitymessageonly();
  public:

  // optional .SessionProtos.DataMessage dataMessage = 1;
  bool has_datamessage() const;
  private:
  bool _internal_has_datamessage() const;
  public:
  void clear_datamessage();
  const ::SessionProtos::DataMessage& datamessage() const;
  PROTOBUF_NODISCARD ::SessionProtos::DataMessage* release_datamessage();
  ::SessionProtos::DataMessage* mutable_datamessage();
  void set_allocated_datamessage(::SessionProtos::DataMessage* datamessage);
  private:
  const ::SessionProtos::DataMessage& _internal_datamessage() const;
  ::SessionProtos::DataMessage* _internal_mutable_datamessage();
  public:
  void unsafe_arena_set_allocated_datamessage(
      ::SessionProtos::DataMessage* datamessage);
  ::SessionProtos::DataMessage* unsafe_arena_release_datamessage();

  // optional .SessionProtos.CallMessage callMessage = 3;
  bool has_callmessage() const;
  private:
  bool _internal_has_callmessage() const;
  public:
  void clear_callmessage();
  const ::SessionProtos::CallMessage& callmessage() const;
  PROTOBUF_NODISCARD ::SessionProtos::CallMessage* release_callmessage();
  ::SessionProtos::CallMessage* mutable_callmessage();
  void set_allocated_callmessage(::SessionProtos::CallMessage* callmessage);
  private:
  const ::SessionProtos::CallMessage& _internal_callmessage() const;
  ::SessionProtos::CallMessage* _internal_mutable_callmessage();
  public:
  void unsafe_arena_set_allocated_callmessage(
      ::SessionProtos::CallMessage* callmessage);
  ::SessionProtos::CallMessage* unsafe_arena_release_callmessage();

  // optional .SessionProtos.ReceiptMessage receiptMessage = 5;
  bool has_receiptmessage() const;
  private:
  bool _internal_has_receiptmessage() const;
  public:
  void clear_receiptmessage();
  const ::SessionProtos::ReceiptMessage& receiptmessage() const;
  PROTOBUF_NODISCARD ::SessionProtos::ReceiptMessage* release_receiptmessage();
  ::SessionProtos::ReceiptMessage* mutable_receiptmessage();
  void set_allocated_receiptmessage(::SessionProtos::ReceiptMessage* receiptmessage);
  private:
  const ::SessionProtos::ReceiptMessage& _internal_receiptmessage() const;
  ::SessionProtos::ReceiptMessage* _internal_mutable_receiptmessage();
  public:
  void unsafe_arena_set_allocated_receiptmessage(
      ::SessionProtos::ReceiptMessage* receiptmessage);
  ::SessionProtos::ReceiptMessage* unsafe_arena_release_receiptmessage();

  // optional .SessionProtos.TypingMessage typingMessage = 6;
  bool has_typingmessage() const;
  private:
  bool _internal_has_typingmessage() const;
  public:
  void clear_typingmessage();
  const ::SessionProtos::TypingMessage& typingmessage() const;
  PROTOBUF_NODISCARD ::SessionProtos::TypingMessage* release_typingmessage();
  ::SessionProtos::TypingMessage* mutable_typingmessage();
  void set_allocated_typingmessage(::SessionProtos::TypingMessage* typingmessage);
  private:
  const ::SessionProtos::TypingMessage& _internal_typingmessage() const;
  ::SessionProtos::TypingMessage* _internal_mutable_typingmessage();
  public:
  void unsafe_arena_set_allocated_typingmessage(
      ::SessionProtos::TypingMessage* typingmessage);
  ::SessionProtos::TypingMessage* unsafe_arena_release_typingmessage();

  // optional .SessionProtos.DataExtractionNotification dataExtractionNotification = 8;
  bool has_dataextractionnotification() const;
  private:
  bool _internal_has_dataextractionnotification() const;
  public:
  void clear_dataextractionnotification();
  const ::SessionProtos::DataExtractionNotification& dataextractionnotification() const;
  PROTOBUF_NODISCARD ::SessionProtos::DataExtractionNotification* release_dataextractionnotification();
  ::SessionProtos::DataExtractionNotification* mutable_dataextractionnotification();
  void set_allocated_dataextractionnotification(::SessionProtos::DataExtractionNotification* dataextractionnotification);
  private:
  const ::SessionProtos::DataExtractionNotification& _internal_dataextractionnotification() const;
  ::SessionProtos::DataExtractionNotification* _internal_mutable_dataextractionnotification();
  public:
  void unsafe_arena_set_allocated_dataextractionnotification(
      ::SessionProtos::DataExtractionNotification* dataextractionnotification);
  ::SessionProtos::DataExtractionNotification* unsafe_arena_release_dataextractionnotification();

  // optional .SessionProtos.UnsendRequest unsendRequest = 9;
  bool has_unsendrequest() const;
  private:
  bool _internal_has_unsendrequest() const;
  public:
  void clear_unsendrequest();
  const ::SessionProtos::UnsendRequest& unsendrequest() const;
  PROTOBUF_NODISCARD ::SessionProtos::UnsendRequest* release_unsendrequest();
  ::SessionProtos::UnsendRequest* mutable_unsendrequest();
  void set_allocated_unsendrequest(::SessionProtos::UnsendRequest* unsendrequest);
  private:
  const ::SessionProtos::UnsendRequest& _internal_unsendrequest() const;
  ::SessionProtos::UnsendRequest* _internal_mutable_unsendrequest();
  public:
  void unsafe_arena_set_allocated_unsendrequest(
      ::SessionProtos::UnsendRequest* unsendrequest);
  ::SessionProtos::UnsendRequest* unsafe_arena_release_unsendrequest();

  // optional .SessionProtos.MessageRequestResponse messageRequestResponse = 10;
  bool has_messagerequestresponse() const;
  private:
  bool _internal_has_messagerequestresponse() const;
  public:
  void clear_messagerequestresponse();
  const ::SessionProtos::MessageRequestResponse& messagerequestresponse() const;
  PROTOBUF_NODISCARD ::SessionProtos::MessageRequestResponse* release_messagerequestresponse();
  ::SessionProtos::MessageRequestResponse* mutable_messagerequestresponse();
  void set_allocated_messagerequestresponse(::SessionProtos::MessageRequestResponse* messagerequestresponse);
  private:
  const ::SessionProtos::MessageRequestResponse& _internal_messagerequestresponse() const;
  ::SessionProtos::MessageRequestResponse* _internal_mutable_messagerequestresponse();
  public:
  void unsafe_arena_set_allocated_messagerequestresponse(
      ::SessionProtos::MessageRequestResponse* messagerequestresponse);
  ::SessionProtos::MessageRequestResponse* unsafe_arena_release_messagerequestresponse();

  // optional .SessionProtos.SharedConfigMessage sharedConfigMessage = 11;
  bool has_sharedconfigmessage() const;
  private:
  bool _internal_has_sharedconfigmessage() const;
  public:
  void clear_sharedconfigmessage();
  const ::SessionProtos::SharedConfigMessage& sharedconfigmessage() const;
  PROTOBUF_NODISCARD ::SessionProtos::SharedConfigMessage* release_sharedconfigmessage();
  ::SessionProtos::SharedConfigMessage* mutable_sharedconfigmessage();
  void set_allocated_sharedconfigmessage(::SessionProtos::SharedConfigMessage* sharedconfigmessage);
  private:
  const ::SessionProtos::SharedConfigMessage& _internal_sharedconfigmessage() const;
  ::SessionProtos::SharedConfigMessage* _internal_mutable_sharedconfigmessage();
  public:
  void unsafe_arena_set_allocated_sharedconfigmessage(
      ::SessionProtos::SharedConfigMessage* sharedconfigmessage);
  ::SessionProtos::SharedConfigMessage* unsafe_arena_release_sharedconfigmessage();

  // optional .SessionProtos.ProMessage proMessage = 16;
  bool has_promessage() const;
  private:
  bool _internal_has_promessage() const;
  public:
  void clear_promessage();
  const ::SessionProtos::ProMessage& promessage() const;
  PROTOBUF_NODISCARD ::SessionProtos::ProMessage* release_promessage();
  ::SessionProtos::ProMessage* mutable_promessage();
  void set_allocated_promessage(::SessionProtos::ProMessage* promessage);
  private:
  const ::SessionProtos::ProMessage& _internal_promessage() const;
  ::SessionProtos::ProMessage* _internal_mutable_promessage();
  public:
  void unsafe_arena_set_allocated_promessage(
      ::SessionProtos::ProMessage* promessage);
  ::SessionProtos::ProMessage* unsafe_arena_release_promessage();

  // optional .SessionProtos.Content.ExpirationType expirationType = 12;
  bool has_expirationtype() const;
  private:
  bool _internal_has_expirationtype() const;
  public:
  void clear_expirationtype();
  ::SessionProtos::Content_ExpirationType expirationtype() const;
  void set_expirationtype(::SessionProtos::Content_ExpirationType value);
  private:
  ::SessionProtos::Content_ExpirationType _internal_expirationtype() const;
  void _internal_set_expirationtype(::SessionProtos::Content_ExpirationType value);
  public:

  // optional uint32 expirationTimer = 13;
  bool has_expirationtimer() const;
  private:
  bool _internal_has_expirationtimer() const;
  public:
  void clear_expirationtimer();
  uint32_t expirationtimer() const;
  void set_expirationtimer(uint32_t value);
  private:
  uint32_t _internal_expirationtimer() const;
  void _internal_set_expirationtimer(uint32_t value);
  public:

  // optional uint64 sigTimestamp = 15;
  bool has_sigtimestamp() const;
  private:
  bool _internal_has_sigtimestamp() const;
  public:
  void clear_sigtimestamp();
  uint64_t sigtimestamp() const;
  void set_sigtimestamp(uint64_t value);
  private:
  uint64_t _internal_sigtimestamp() const;
  void _internal_set_sigtimestamp(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:SessionProtos.Content)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr prosigforcommunitymessageonly_;
    ::SessionProtos::DataMessage* datamessage_;
    ::SessionProtos::CallMessage* callmessage_;
    ::SessionProtos::ReceiptMessage* receiptmessage_;
    ::SessionProtos::TypingMessage* typingmessage_;
    ::SessionProtos::DataExtractionNotification* dataextractionnotification_;
    ::SessionProtos::UnsendRequest* unsendrequest_;
    ::SessionProtos::MessageRequestResponse* messagerequestresponse_;
    ::SessionProtos::SharedConfigMessage* sharedconfigmessage_;
    ::SessionProtos::ProMessage* promessage_;
    int expirationtype_;
    uint32_t expirationtimer_;
    uint64_t sigtimestamp_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_SessionProtos_2eproto;
};
// -------------------------------------------------------------------

class CallMessage final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:SessionProtos.CallMessage) */ {
 public:
  inline CallMessage() : CallMessage(nullptr) {}
  ~CallMessage() override;
  explicit PROTOBUF_CONSTEXPR CallMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline CallMessage& operator=(const CallMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline CallMessage& operator=(CallMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const CallMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const CallMessage* internal_default_instance() {
    return reinterpret_cast<const CallMessage*>(
               &_CallMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

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

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

  CallMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CallMessage>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const CallMessage& from);
  void MergeFrom(const CallMessage& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(CallMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SessionProtos.CallMessage";
  }
  protected:
  explicit CallMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

  typedef CallMessage_Type Type;
  static constexpr Type PRE_OFFER =
    CallMessage_Type_PRE_OFFER;
  static constexpr Type OFFER =
    CallMessage_Type_OFFER;
  static constexpr Type ANSWER =
    CallMessage_Type_ANSWER;
  static constexpr Type PROVISIONAL_ANSWER =
    CallMessage_Type_PROVISIONAL_ANSWER;
  static constexpr Type ICE_CANDIDATES =
    CallMessage_Type_ICE_CANDIDATES;
  static constexpr Type END_CALL =
    CallMessage_Type_END_CALL;
  static inline bool Type_IsValid(int value) {
    return CallMessage_Type_IsValid(value);
  }
  static constexpr Type Type_MIN =
    CallMessage_Type_Type_MIN;
  static constexpr Type Type_MAX =
    CallMessage_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE =
    CallMessage_Type_Type_ARRAYSIZE;
  template<typename T>
  static inline const std::string& Type_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Type>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Type_Name.");
    return CallMessage_Type_Name(enum_t_value);
  }
  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Type* value) {
    return CallMessage_Type_Parse(name, value);
  }

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

  enum : int {
    kSdpsFieldNumber = 2,
    kSdpMLineIndexesFieldNumber = 3,
    kSdpMidsFieldNumber = 4,
    kUuidFieldNumber = 5,
    kTypeFieldNumber = 1,
  };
  // repeated string sdps = 2;
  int sdps_size() const;
  private:
  int _internal_sdps_size() const;
  public:
  void clear_sdps();
  const std::string& sdps(int index) const;
  std::string* mutable_sdps(int index);
  void set_sdps(int index, const std::string& value);
  void set_sdps(int index, std::string&& value);
  void set_sdps(int index, const char* value);
  void set_sdps(int index, const char* value, size_t size);
  std::string* add_sdps();
  void add_sdps(const std::string& value);
  void add_sdps(std::string&& value);
  void add_sdps(const char* value);
  void add_sdps(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& sdps() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_sdps();
  private:
  const std::string& _internal_sdps(int index) const;
  std::string* _internal_add_sdps();
  public:

  // repeated uint32 sdpMLineIndexes = 3;
  int sdpmlineindexes_size() const;
  private:
  int _internal_sdpmlineindexes_size() const;
  public:
  void clear_sdpmlineindexes();
  private:
  uint32_t _internal_sdpmlineindexes(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_sdpmlineindexes() const;
  void _internal_add_sdpmlineindexes(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_sdpmlineindexes();
  public:
  uint32_t sdpmlineindexes(int index) const;
  void set_sdpmlineindexes(int index, uint32_t value);
  void add_sdpmlineindexes(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      sdpmlineindexes() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_sdpmlineindexes();

  // repeated string sdpMids = 4;
  int sdpmids_size() const;
  private:
  int _internal_sdpmids_size() const;
  public:
  void clear_sdpmids();
  const std::string& sdpmids(int index) const;
  std::string* mutable_sdpmids(int index);
  void set_sdpmids(int index, const std::string& value);
  void set_sdpmids(int index, std::string&& value);
  void set_sdpmids(int index, const char* value);
  void set_sdpmids(int index, const char* value, size_t size);
  std::string* add_sdpmids();
  void add_sdpmids(const std::string& value);
  void add_sdpmids(std::string&& value);
  void add_sdpmids(const char* value);
  void add_sdpmids(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& sdpmids() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_sdpmids();
  private:
  const std::string& _internal_sdpmids(int index) const;
  std::string* _internal_add_sdpmids();
  public:

  // required string uuid = 5;
  bool has_uuid() const;
  private:
  bool _internal_has_uuid() const;
  public:
  void clear_uuid();
  const std::string& uuid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_uuid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_uuid();
  PROTOBUF_NODISCARD std::string* release_uuid();
  void set_allocated_uuid(std::string* uuid);
  private:
  const std::string& _internal_uuid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_uuid(const std::string& value);
  std::string* _internal_mutable_uuid();
  public:

  // required .SessionProtos.CallMessage.Type type = 1;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::SessionProtos::CallMessage_Type type() const;
  void set_type(::SessionProtos::CallMessage_Type value);
  private:
  ::SessionProtos::CallMessage_Type _internal_type() const;
  void _internal_set_type(::SessionProtos::CallMessage_Type value);
  public:

  // @@protoc_insertion_point(class_scope:SessionProtos.CallMessage)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> sdps_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > sdpmlineindexes_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> sdpmids_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uuid_;
    int type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_SessionProtos_2eproto;
};
// -------------------------------------------------------------------

class KeyPair final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:SessionProtos.KeyPair) */ {
 public:
  inline KeyPair() : KeyPair(nullptr) {}
  ~KeyPair() override;
  explicit PROTOBUF_CONSTEXPR KeyPair(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline KeyPair& operator=(const KeyPair& from) {
    CopyFrom(from);
    return *this;
  }
  inline KeyPair& operator=(KeyPair&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const KeyPair& default_instance() {
    return *internal_default_instance();
  }
  static inline const KeyPair* internal_default_instance() {
    return reinterpret_cast<const KeyPair*>(
               &_KeyPair_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

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

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

  KeyPair* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<KeyPair>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const KeyPair& from);
  void MergeFrom(const KeyPair& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(KeyPair* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SessionProtos.KeyPair";
  }
  protected:
  explicit KeyPair(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kPublicKeyFieldNumber = 1,
    kPrivateKeyFieldNumber = 2,
  };
  // required bytes publicKey = 1;
  bool has_publickey() const;
  private:
  bool _internal_has_publickey() const;
  public:
  void clear_publickey();
  const std::string& publickey() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_publickey(ArgT0&& arg0, ArgT... args);
  std::string* mutable_publickey();
  PROTOBUF_NODISCARD std::string* release_publickey();
  void set_allocated_publickey(std::string* publickey);
  private:
  const std::string& _internal_publickey() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_publickey(const std::string& value);
  std::string* _internal_mutable_publickey();
  public:

  // required bytes privateKey = 2;
  bool has_privatekey() const;
  private:
  bool _internal_has_privatekey() const;
  public:
  void clear_privatekey();
  const std::string& privatekey() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_privatekey(ArgT0&& arg0, ArgT... args);
  std::string* mutable_privatekey();
  PROTOBUF_NODISCARD std::string* release_privatekey();
  void set_allocated_privatekey(std::string* privatekey);
  private:
  const std::string& _internal_privatekey() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_privatekey(const std::string& value);
  std::string* _internal_mutable_privatekey();
  public:

  // @@protoc_insertion_point(class_scope:SessionProtos.KeyPair)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr publickey_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr privatekey_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_SessionProtos_2eproto;
};
// -------------------------------------------------------------------

class DataExtractionNotification final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:SessionProtos.DataExtractionNotification) */ {
 public:
  inline DataExtractionNotification() : DataExtractionNotification(nullptr) {}
  ~DataExtractionNotification() override;
  explicit PROTOBUF_CONSTEXPR DataExtractionNotification(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline DataExtractionNotification& operator=(const DataExtractionNotification& from) {
    CopyFrom(from);
    return *this;
  }
  inline DataExtractionNotification& operator=(DataExtractionNotification&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const DataExtractionNotification& default_instance() {
    return *internal_default_instance();
  }
  static inline const DataExtractionNotification* internal_default_instance() {
    return reinterpret_cast<const DataExtractionNotification*>(
               &_DataExtractionNotification_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

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

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

  DataExtractionNotification* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DataExtractionNotification>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const DataExtractionNotification& from);
  void MergeFrom(const DataExtractionNotification& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(DataExtractionNotification* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SessionProtos.DataExtractionNotification";
  }
  protected:
  explicit DataExtractionNotification(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

  typedef DataExtractionNotification_Type Type;
  static constexpr Type SCREENSHOT =
    DataExtractionNotification_Type_SCREENSHOT;
  static constexpr Type MEDIA_SAVED =
    DataExtractionNotification_Type_MEDIA_SAVED;
  static inline bool Type_IsValid(int value) {
    return DataExtractionNotification_Type_IsValid(value);
  }
  static constexpr Type Type_MIN =
    DataExtractionNotification_Type_Type_MIN;
  static constexpr Type Type_MAX =
    DataExtractionNotification_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE =
    DataExtractionNotification_Type_Type_ARRAYSIZE;
  template<typename T>
  static inline const std::string& Type_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Type>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Type_Name.");
    return DataExtractionNotification_Type_Name(enum_t_value);
  }
  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Type* value) {
    return DataExtractionNotification_Type_Parse(name, value);
  }

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

  enum : int {
    kTimestampFieldNumber = 2,
    kTypeFieldNumber = 1,
  };
  // optional uint64 timestamp = 2;
  bool has_timestamp() const;
  private:
  bool _internal_has_timestamp() const;
  public:
  void clear_timestamp();
  uint64_t timestamp() const;
  void set_timestamp(uint64_t value);
  private:
  uint64_t _internal_timestamp() const;
  void _internal_set_timestamp(uint64_t value);
  public:

  // required .SessionProtos.DataExtractionNotification.Type type = 1;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::SessionProtos::DataExtractionNotification_Type type() const;
  void set_type(::SessionProtos::DataExtractionNotification_Type value);
  private:
  ::SessionProtos::DataExtractionNotification_Type _internal_type() const;
  void _internal_set_type(::SessionProtos::DataExtractionNotification_Type value);
  public:

  // @@protoc_insertion_point(class_scope:SessionProtos.DataExtractionNotification)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint64_t timestamp_;
    int type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_SessionProtos_2eproto;
};
// -------------------------------------------------------------------

class LokiProfile final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:SessionProtos.LokiProfile) */ {
 public:
  inline LokiProfile() : LokiProfile(nullptr) {}
  ~LokiProfile() override;
  explicit PROTOBUF_CONSTEXPR LokiProfile(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline LokiProfile& operator=(const LokiProfile& from) {
    CopyFrom(from);
    return *this;
  }
  inline LokiProfile& operator=(LokiProfile&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const LokiProfile& default_instance() {
    return *internal_default_instance();
  }
  static inline const LokiProfile* internal_default_instance() {
    return reinterpret_cast<const LokiProfile*>(
               &_LokiProfile_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

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

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

  LokiProfile* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LokiProfile>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const LokiProfile& from);
  void MergeFrom(const LokiProfile& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(LokiProfile* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SessionProtos.LokiProfile";
  }
  protected:
  explicit LokiProfile(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kDisplayNameFieldNumber = 1,
    kProfilePictureFieldNumber = 2,
    kLastUpdateSecondsFieldNumber = 3,
  };
  // optional string displayName = 1;
  bool has_displayname() const;
  private:
  bool _internal_has_displayname() const;
  public:
  void clear_displayname();
  const std::string& displayname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_displayname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_displayname();
  PROTOBUF_NODISCARD std::string* release_displayname();
  void set_allocated_displayname(std::string* displayname);
  private:
  const std::string& _internal_displayname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_displayname(const std::string& value);
  std::string* _internal_mutable_displayname();
  public:

  // optional string profilePicture = 2;
  bool has_profilepicture() const;
  private:
  bool _internal_has_profilepicture() const;
  public:
  void clear_profilepicture();
  const std::string& profilepicture() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_profilepicture(ArgT0&& arg0, ArgT... args);
  std::string* mutable_profilepicture();
  PROTOBUF_NODISCARD std::string* release_profilepicture();
  void set_allocated_profilepicture(std::string* profilepicture);
  private:
  const std::string& _internal_profilepicture() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_profilepicture(const std::string& value);
  std::string* _internal_mutable_profilepicture();
  public:

  // optional uint64 lastUpdateSeconds = 3;
  bool has_lastupdateseconds() const;
  private:
  bool _internal_has_lastupdateseconds() const;
  public:
  void clear_lastupdateseconds();
  uint64_t lastupdateseconds() const;
  void set_lastupdateseconds(uint64_t value);
  private:
  uint64_t _internal_lastupdateseconds() const;
  void _internal_set_lastupdateseconds(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:SessionProtos.LokiProfile)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr displayname_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr profilepicture_;
    uint64_t lastupdateseconds_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_SessionProtos_2eproto;
};
// -------------------------------------------------------------------

class DataMessage_Quote_QuotedAttachment final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:SessionProtos.DataMessage.Quote.QuotedAttachment) */ {
 public:
  inline DataMessage_Quote_QuotedAttachment() : DataMessage_Quote_QuotedAttachment(nullptr) {}
  ~DataMessage_Quote_QuotedAttachment() override;
  explicit PROTOBUF_CONSTEXPR DataMessage_Quote_QuotedAttachment(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline DataMessage_Quote_QuotedAttachment& operator=(const DataMessage_Quote_QuotedAttachment& from) {
    CopyFrom(from);
    return *this;
  }
  inline DataMessage_Quote_QuotedAttachment& operator=(DataMessage_Quote_QuotedAttachment&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const DataMessage_Quote_QuotedAttachment& default_instance() {
    return *internal_default_instance();
  }
  static inline const DataMessage_Quote_QuotedAttachment* internal_default_instance() {
    return reinterpret_cast<const DataMessage_Quote_QuotedAttachment*>(
               &_DataMessage_Quote_QuotedAttachment_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

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

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

  DataMessage_Quote_QuotedAttachment* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DataMessage_Quote_QuotedAttachment>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const DataMessage_Quote_QuotedAttachment& from);
  void MergeFrom(const DataMessage_Quote_QuotedAttachment& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(DataMessage_Quote_QuotedAttachment* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SessionProtos.DataMessage.Quote.QuotedAttachment";
  }
  protected:
  explicit DataMessage_Quote_QuotedAttachment(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

  typedef DataMessage_Quote_QuotedAttachment_Flags Flags;
  static constexpr Flags VOICE_MESSAGE =
    DataMessage_Quote_QuotedAttachment_Flags_VOICE_MESSAGE;
  static inline bool Flags_IsValid(int value) {
    return DataMessage_Quote_QuotedAttachment_Flags_IsValid(value);
  }
  static constexpr Flags Flags_MIN =
    DataMessage_Quote_QuotedAttachment_Flags_Flags_MIN;
  static constexpr Flags Flags_MAX =
    DataMessage_Quote_QuotedAttachment_Flags_Flags_MAX;
  static constexpr int Flags_ARRAYSIZE =
    DataMessage_Quote_QuotedAttachment_Flags_Flags_ARRAYSIZE;
  template<typename T>
  static inline const std::string& Flags_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Flags>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Flags_Name.");
    return DataMessage_Quote_QuotedAttachment_Flags_Name(enum_t_value);
  }
  static inline bool Flags_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Flags* value) {
    return DataMessage_Quote_QuotedAttachment_Flags_Parse(name, value);
  }

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

  enum : int {
    kContentTypeFieldNumber = 1,
    kFileNameFieldNumber = 2,
    kThumbnailFieldNumber = 3,
    kFlagsFieldNumber = 4,
  };
  // optional string contentType = 1;
  bool has_contenttype() const;
  private:
  bool _internal_has_contenttype() const;
  public:
  void clear_contenttype();
  const std::string& contenttype() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_contenttype(ArgT0&& arg0, ArgT... args);
  std::string* mutable_contenttype();
  PROTOBUF_NODISCARD std::string* release_contenttype();
  void set_allocated_contenttype(std::string* contenttype);
  private:
  const std::string& _internal_contenttype() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_contenttype(const std::string& value);
  std::string* _internal_mutable_contenttype();
  public:

  // optional string fileName = 2;
  bool has_filename() const;
  private:
  bool _internal_has_filename() const;
  public:
  void clear_filename();
  const std::string& filename() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_filename(ArgT0&& arg0, ArgT... args);
  std::string* mutable_filename();
  PROTOBUF_NODISCARD std::string* release_filename();
  void set_allocated_filename(std::string* filename);
  private:
  const std::string& _internal_filename() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_filename(const std::string& value);
  std::string* _internal_mutable_filename();
  public:

  // optional .SessionProtos.AttachmentPointer thumbnail = 3;
  bool has_thumbnail() const;
  private:
  bool _internal_has_thumbnail() const;
  public:
  void clear_thumbnail();
  const ::SessionProtos::AttachmentPointer& thumbnail() const;
  PROTOBUF_NODISCARD ::SessionProtos::AttachmentPointer* release_thumbnail();
  ::SessionProtos::AttachmentPointer* mutable_thumbnail();
  void set_allocated_thumbnail(::SessionProtos::AttachmentPointer* thumbnail);
  private:
  const ::SessionProtos::AttachmentPointer& _internal_thumbnail() const;
  ::SessionProtos::AttachmentPointer* _internal_mutable_thumbnail();
  public:
  void unsafe_arena_set_allocated_thumbnail(
      ::SessionProtos::AttachmentPointer* thumbnail);
  ::SessionProtos::AttachmentPointer* unsafe_arena_release_thumbnail();

  // optional uint32 flags = 4;
  bool has_flags() const;
  private:
  bool _internal_has_flags() const;
  public:
  void clear_flags();
  uint32_t flags() const;
  void set_flags(uint32_t value);
  private:
  uint32_t _internal_flags() const;
  void _internal_set_flags(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:SessionProtos.DataMessage.Quote.QuotedAttachment)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr contenttype_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filename_;
    ::SessionProtos::AttachmentPointer* thumbnail_;
    uint32_t flags_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_SessionProtos_2eproto;
};
// -------------------------------------------------------------------

class DataMessage_Quote final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:SessionProtos.DataMessage.Quote) */ {
 public:
  inline DataMessage_Quote() : DataMessage_Quote(nullptr) {}
  ~DataMessage_Quote() override;
  explicit PROTOBUF_CONSTEXPR DataMessage_Quote(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline DataMessage_Quote& operator=(const DataMessage_Quote& from) {
    CopyFrom(from);
    return *this;
  }
  inline DataMessage_Quote& operator=(DataMessage_Quote&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const DataMessage_Quote& default_instance() {
    return *internal_default_instance();
  }
  static inline const DataMessage_Quote* internal_default_instance() {
    return reinterpret_cast<const DataMessage_Quote*>(
               &_DataMessage_Quote_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

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

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

  DataMessage_Quote* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DataMessage_Quote>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const DataMessage_Quote& from);
  void MergeFrom(const DataMessage_Quote& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(DataMessage_Quote* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SessionProtos.DataMessage.Quote";
  }
  protected:
  explicit DataMessage_Quote(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

  typedef DataMessage_Quote_QuotedAttachment QuotedAttachment;

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

  enum : int {
    kAttachmentsFieldNumber = 4,
    kAuthorFieldNumber = 2,
    kTextFieldNumber = 3,
    kIdFieldNumber = 1,
  };
  // repeated .SessionProtos.DataMessage.Quote.QuotedAttachment attachments = 4;
  int attachments_size() const;
  private:
  int _internal_attachments_size() const;
  public:
  void clear_attachments();
  ::SessionProtos::DataMessage_Quote_QuotedAttachment* mutable_attachments(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SessionProtos::DataMessage_Quote_QuotedAttachment >*
      mutable_attachments();
  private:
  const ::SessionProtos::DataMessage_Quote_QuotedAttachment& _internal_attachments(int index) const;
  ::SessionProtos::DataMessage_Quote_QuotedAttachment* _internal_add_attachments();
  public:
  const ::SessionProtos::DataMessage_Quote_QuotedAttachment& attachments(int index) const;
  ::SessionProtos::DataMessage_Quote_QuotedAttachment* add_attachments();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SessionProtos::DataMessage_Quote_QuotedAttachment >&
      attachments() const;

  // required string author = 2;
  bool has_author() const;
  private:
  bool _internal_has_author() const;
  public:
  void clear_author();
  const std::string& author() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_author(ArgT0&& arg0, ArgT... args);
  std::string* mutable_author();
  PROTOBUF_NODISCARD std::string* release_author();
  void set_allocated_author(std::string* author);
  private:
  const std::string& _internal_author() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_author(const std::string& value);
  std::string* _internal_mutable_author();
  public:

  // optional string text = 3;
  bool has_text() const;
  private:
  bool _internal_has_text() const;
  public:
  void clear_text();
  const std::string& text() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_text(ArgT0&& arg0, ArgT... args);
  std::string* mutable_text();
  PROTOBUF_NODISCARD std::string* release_text();
  void set_allocated_text(std::string* text);
  private:
  const std::string& _internal_text() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value);
  std::string* _internal_mutable_text();
  public:

  // required uint64 id = 1;
  bool has_id() const;
  private:
  bool _internal_has_id() const;
  public:
  void clear_id();
  uint64_t id() const;
  void set_id(uint64_t value);
  private:
  uint64_t _internal_id() const;
  void _internal_set_id(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:SessionProtos.DataMessage.Quote)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SessionProtos::DataMessage_Quote_QuotedAttachment > attachments_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr author_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_;
    uint64_t id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_SessionProtos_2eproto;
};
// -------------------------------------------------------------------

class DataMessage_Preview final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:SessionProtos.DataMessage.Preview) */ {
 public:
  inline DataMessage_Preview() : DataMessage_Preview(nullptr) {}
  ~DataMessage_Preview() override;
  explicit PROTOBUF_CONSTEXPR DataMessage_Preview(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline DataMessage_Preview& operator=(const DataMessage_Preview& from) {
    CopyFrom(from);
    return *this;
  }
  inline DataMessage_Preview& operator=(DataMessage_Preview&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const DataMessage_Preview& default_instance() {
    return *internal_default_instance();
  }
  static inline const DataMessage_Preview* internal_default_instance() {
    return reinterpret_cast<const DataMessage_Preview*>(
               &_DataMessage_Preview_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

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

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

  DataMessage_Preview* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DataMessage_Preview>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const DataMessage_Preview& from);
  void MergeFrom(const DataMessage_Preview& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(DataMessage_Preview* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SessionProtos.DataMessage.Preview";
  }
  protected:
  explicit DataMessage_Preview(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kUrlFieldNumber = 1,
    kTitleFieldNumber = 2,
    kImageFieldNumber = 3,
  };
  // required string url = 1;
  bool has_url() const;
  private:
  bool _internal_has_url() const;
  public:
  void clear_url();
  const std::string& url() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_url(ArgT0&& arg0, ArgT... args);
  std::string* mutable_url();
  PROTOBUF_NODISCARD std::string* release_url();
  void set_allocated_url(std::string* url);
  private:
  const std::string& _internal_url() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value);
  std::string* _internal_mutable_url();
  public:

  // optional string title = 2;
  bool has_title() const;
  private:
  bool _internal_has_title() const;
  public:
  void clear_title();
  const std::string& title() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_title(ArgT0&& arg0, ArgT... args);
  std::string* mutable_title();
  PROTOBUF_NODISCARD std::string* release_title();
  void set_allocated_title(std::string* title);
  private:
  const std::string& _internal_title() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value);
  std::string* _internal_mutable_title();
  public:

  // optional .SessionProtos.AttachmentPointer image = 3;
  bool has_image() const;
  private:
  bool _internal_has_image() const;
  public:
  void clear_image();
  const ::SessionProtos::AttachmentPointer& image() const;
  PROTOBUF_NODISCARD ::SessionProtos::AttachmentPointer* release_image();
  ::SessionProtos::AttachmentPointer* mutable_image();
  void set_allocated_image(::SessionProtos::AttachmentPointer* image);
  private:
  const ::SessionProtos::AttachmentPointer& _internal_image() const;
  ::SessionProtos::AttachmentPointer* _internal_mutable_image();
  public:
  void unsafe_arena_set_allocated_image(
      ::SessionProtos::AttachmentPointer* image);
  ::SessionProtos::AttachmentPointer* unsafe_arena_release_image();

  // @@protoc_insertion_point(class_scope:SessionProtos.DataMessage.Preview)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_;
    ::SessionProtos::AttachmentPointer* image_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_SessionProtos_2eproto;
};
// -------------------------------------------------------------------

class DataMessage_Reaction final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:SessionProtos.DataMessage.Reaction) */ {
 public:
  inline DataMessage_Reaction() : DataMessage_Reaction(nullptr) {}
  ~DataMessage_Reaction() override;
  explicit PROTOBUF_CONSTEXPR DataMessage_Reaction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline DataMessage_Reaction& operator=(const DataMessage_Reaction& from) {
    CopyFrom(from);
    return *this;
  }
  inline DataMessage_Reaction& operator=(DataMessage_Reaction&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const DataMessage_Reaction& default_instance() {
    return *internal_default_instance();
  }
  static inline const DataMessage_Reaction* internal_default_instance() {
    return reinterpret_cast<const DataMessage_Reaction*>(
               &_DataMessage_Reaction_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

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

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

  DataMessage_Reaction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DataMessage_Reaction>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const DataMessage_Reaction& from);
  void MergeFrom(const DataMessage_Reaction& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(DataMessage_Reaction* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SessionProtos.DataMessage.Reaction";
  }
  protected:
  explicit DataMessage_Reaction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

  typedef DataMessage_Reaction_Action Action;
  static constexpr Action REACT =
    DataMessage_Reaction_Action_REACT;
  static constexpr Action REMOVE =
    DataMessage_Reaction_Action_REMOVE;
  static inline bool Action_IsValid(int value) {
    return DataMessage_Reaction_Action_IsValid(value);
  }
  static constexpr Action Action_MIN =
    DataMessage_Reaction_Action_Action_MIN;
  static constexpr Action Action_MAX =
    DataMessage_Reaction_Action_Action_MAX;
  static constexpr int Action_ARRAYSIZE =
    DataMessage_Reaction_Action_Action_ARRAYSIZE;
  template<typename T>
  static inline const std::string& Action_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Action>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Action_Name.");
    return DataMessage_Reaction_Action_Name(enum_t_value);
  }
  static inline bool Action_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Action* value) {
    return DataMessage_Reaction_Action_Parse(name, value);
  }

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

  enum : int {
    kAuthorFieldNumber = 2,
    kEmojiFieldNumber = 3,
    kIdFieldNumber = 1,
    kActionFieldNumber = 4,
  };
  // required string author = 2;
  bool has_author() const;
  private:
  bool _internal_has_author() const;
  public:
  void clear_author();
  const std::string& author() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_author(ArgT0&& arg0, ArgT... args);
  std::string* mutable_author();
  PROTOBUF_NODISCARD std::string* release_author();
  void set_allocated_author(std::string* author);
  private:
  const std::string& _internal_author() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_author(const std::string& value);
  std::string* _internal_mutable_author();
  public:

  // optional string emoji = 3;
  bool has_emoji() const;
  private:
  bool _internal_has_emoji() const;
  public:
  void clear_emoji();
  const std::string& emoji() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_emoji(ArgT0&& arg0, ArgT... args);
  std::string* mutable_emoji();
  PROTOBUF_NODISCARD std::string* release_emoji();
  void set_allocated_emoji(std::string* emoji);
  private:
  const std::string& _internal_emoji() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_emoji(const std::string& value);
  std::string* _internal_mutable_emoji();
  public:

  // required uint64 id = 1;
  bool has_id() const;
  private:
  bool _internal_has_id() const;
  public:
  void clear_id();
  uint64_t id() const;
  void set_id(uint64_t value);
  private:
  uint64_t _internal_id() const;
  void _internal_set_id(uint64_t value);
  public:

  // required .SessionProtos.DataMessage.Reaction.Action action = 4;
  bool has_action() const;
  private:
  bool _internal_has_action() const;
  public:
  void clear_action();
  ::SessionProtos::DataMessage_Reaction_Action action() const;
  void set_action(::SessionProtos::DataMessage_Reaction_Action value);
  private:
  ::SessionProtos::DataMessage_Reaction_Action _internal_action() const;
  void _internal_set_action(::SessionProtos::DataMessage_Reaction_Action value);
  public:

  // @@protoc_insertion_point(class_scope:SessionProtos.DataMessage.Reaction)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr author_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr emoji_;
    uint64_t id_;
    int action_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_SessionProtos_2eproto;
};
// -------------------------------------------------------------------

class DataMessage_OpenGroupInvitation final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:SessionProtos.DataMessage.OpenGroupInvitation) */ {
 public:
  inline DataMessage_OpenGroupInvitation() : DataMessage_OpenGroupInvitation(nullptr) {}
  ~DataMessage_OpenGroupInvitation() override;
  explicit PROTOBUF_CONSTEXPR DataMessage_OpenGroupInvitation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline DataMessage_OpenGroupInvitation& operator=(const DataMessage_OpenGroupInvitation& from) {
    CopyFrom(from);
    return *this;
  }
  inline DataMessage_OpenGroupInvitation& operator=(DataMessage_OpenGroupInvitation&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const DataMessage_OpenGroupInvitation& default_instance() {
    return *internal_default_instance();
  }
  static inline const DataMessage_OpenGroupInvitation* internal_default_instance() {
    return reinterpret_cast<const DataMessage_OpenGroupInvitation*>(
               &_DataMessage_OpenGroupInvitation_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

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

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

  DataMessage_OpenGroupInvitation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DataMessage_OpenGroupInvitation>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const DataMessage_OpenGroupInvitation& from);
  void MergeFrom(const DataMessage_OpenGroupInvitation& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(DataMessage_OpenGroupInvitation* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SessionProtos.DataMessage.OpenGroupInvitation";
  }
  protected:
  explicit DataMessage_OpenGroupInvitation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kUrlFieldNumber = 1,
    kNameFieldNumber = 3,
  };
  // required string url = 1;
  bool has_url() const;
  private:
  bool _internal_has_url() const;
  public:
  void clear_url();
  const std::string& url() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_url(ArgT0&& arg0, ArgT... args);
  std::string* mutable_url();
  PROTOBUF_NODISCARD std::string* release_url();
  void set_allocated_url(std::string* url);
  private:
  const std::string& _internal_url() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value);
  std::string* _internal_mutable_url();
  public:

  // required string name = 3;
  bool has_name() const;
  private:
  bool _internal_has_name() const;
  public:
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // @@protoc_insertion_point(class_scope:SessionProtos.DataMessage.OpenGroupInvitation)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_SessionProtos_2eproto;
};
// -------------------------------------------------------------------

class DataMessage final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:SessionProtos.DataMessage) */ {
 public:
  inline DataMessage() : DataMessage(nullptr) {}
  ~DataMessage() override;
  explicit PROTOBUF_CONSTEXPR DataMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline DataMessage& operator=(const DataMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline DataMessage& operator=(DataMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const DataMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const DataMessage* internal_default_instance() {
    return reinterpret_cast<const DataMessage*>(
               &_DataMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

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

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

  DataMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DataMessage>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const DataMessage& from);
  void MergeFrom(const DataMessage& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(DataMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SessionProtos.DataMessage";
  }
  protected:
  explicit DataMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

  typedef DataMessage_Quote Quote;
  typedef DataMessage_Preview Preview;
  typedef DataMessage_Reaction Reaction;
  typedef DataMessage_OpenGroupInvitation OpenGroupInvitation;

  typedef DataMessage_Flags Flags;
  static constexpr Flags EXPIRATION_TIMER_UPDATE =
    DataMessage_Flags_EXPIRATION_TIMER_UPDATE;
  static inline bool Flags_IsValid(int value) {
    return DataMessage_Flags_IsValid(value);
  }
  static constexpr Flags Flags_MIN =
    DataMessage_Flags_Flags_MIN;
  static constexpr Flags Flags_MAX =
    DataMessage_Flags_Flags_MAX;
  static constexpr int Flags_ARRAYSIZE =
    DataMessage_Flags_Flags_ARRAYSIZE;
  template<typename T>
  static inline const std::string& Flags_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Flags>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Flags_Name.");
    return DataMessage_Flags_Name(enum_t_value);
  }
  static inline bool Flags_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Flags* value) {
    return DataMessage_Flags_Parse(name, value);
  }

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

  enum : int {
    kAttachmentsFieldNumber = 2,
    kPreviewFieldNumber = 10,
    kBodyFieldNumber = 1,
    kProfileKeyFieldNumber = 6,
    kSyncTargetFieldNumber = 105,
    kQuoteFieldNumber = 8,
    kReactionFieldNumber = 11,
    kProfileFieldNumber = 101,
    kOpenGroupInvitationFieldNumber = 102,
    kGroupUpdateMessageFieldNumber = 120,
    kTimestampFieldNumber = 7,
    kFlagsFieldNumber = 4,
    kBlocksCommunityMessageRequestsFieldNumber = 106,
  };
  // repeated .SessionProtos.AttachmentPointer attachments = 2;
  int attachments_size() const;
  private:
  int _internal_attachments_size() const;
  public:
  void clear_attachments();
  ::SessionProtos::AttachmentPointer* mutable_attachments(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SessionProtos::AttachmentPointer >*
      mutable_attachments();
  private:
  const ::SessionProtos::AttachmentPointer& _internal_attachments(int index) const;
  ::SessionProtos::AttachmentPointer* _internal_add_attachments();
  public:
  const ::SessionProtos::AttachmentPointer& attachments(int index) const;
  ::SessionProtos::AttachmentPointer* add_attachments();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SessionProtos::AttachmentPointer >&
      attachments() const;

  // repeated .SessionProtos.DataMessage.Preview preview = 10;
  int preview_size() const;
  private:
  int _internal_preview_size() const;
  public:
  void clear_preview();
  ::SessionProtos::DataMessage_Preview* mutable_preview(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SessionProtos::DataMessage_Preview >*
      mutable_preview();
  private:
  const ::SessionProtos::DataMessage_Preview& _internal_preview(int index) const;
  ::SessionProtos::DataMessage_Preview* _internal_add_preview();
  public:
  const ::SessionProtos::DataMessage_Preview& preview(int index) const;
  ::SessionProtos::DataMessage_Preview* add_preview();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SessionProtos::DataMessage_Preview >&
      preview() const;

  // optional string body = 1;
  bool has_body() const;
  private:
  bool _internal_has_body() const;
  public:
  void clear_body();
  const std::string& body() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_body(ArgT0&& arg0, ArgT... args);
  std::string* mutable_body();
  PROTOBUF_NODISCARD std::string* release_body();
  void set_allocated_body(std::string* body);
  private:
  const std::string& _internal_body() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_body(const std::string& value);
  std::string* _internal_mutable_body();
  public:

  // optional bytes profileKey = 6;
  bool has_profilekey() const;
  private:
  bool _internal_has_profilekey() const;
  public:
  void clear_profilekey();
  const std::string& profilekey() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_profilekey(ArgT0&& arg0, ArgT... args);
  std::string* mutable_profilekey();
  PROTOBUF_NODISCARD std::string* release_profilekey();
  void set_allocated_profilekey(std::string* profilekey);
  private:
  const std::string& _internal_profilekey() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_profilekey(const std::string& value);
  std::string* _internal_mutable_profilekey();
  public:

  // optional string syncTarget = 105;
  bool has_synctarget() const;
  private:
  bool _internal_has_synctarget() const;
  public:
  void clear_synctarget();
  const std::string& synctarget() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_synctarget(ArgT0&& arg0, ArgT... args);
  std::string* mutable_synctarget();
  PROTOBUF_NODISCARD std::string* release_synctarget();
  void set_allocated_synctarget(std::string* synctarget);
  private:
  const std::string& _internal_synctarget() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_synctarget(const std::string& value);
  std::string* _internal_mutable_synctarget();
  public:

  // optional .SessionProtos.DataMessage.Quote quote = 8;
  bool has_quote() const;
  private:
  bool _internal_has_quote() const;
  public:
  void clear_quote();
  const ::SessionProtos::DataMessage_Quote& quote() const;
  PROTOBUF_NODISCARD ::SessionProtos::DataMessage_Quote* release_quote();
  ::SessionProtos::DataMessage_Quote* mutable_quote();
  void set_allocated_quote(::SessionProtos::DataMessage_Quote* quote);
  private:
  const ::SessionProtos::DataMessage_Quote& _internal_quote() const;
  ::SessionProtos::DataMessage_Quote* _internal_mutable_quote();
  public:
  void unsafe_arena_set_allocated_quote(
      ::SessionProtos::DataMessage_Quote* quote);
  ::SessionProtos::DataMessage_Quote* unsafe_arena_release_quote();

  // optional .SessionProtos.DataMessage.Reaction reaction = 11;
  bool has_reaction() const;
  private:
  bool _internal_has_reaction() const;
  public:
  void clear_reaction();
  const ::SessionProtos::DataMessage_Reaction& reaction() const;
  PROTOBUF_NODISCARD ::SessionProtos::DataMessage_Reaction* release_reaction();
  ::SessionProtos::DataMessage_Reaction* mutable_reaction();
  void set_allocated_reaction(::SessionProtos::DataMessage_Reaction* reaction);
  private:
  const ::SessionProtos::DataMessage_Reaction& _internal_reaction() const;
  ::SessionProtos::DataMessage_Reaction* _internal_mutable_reaction();
  public:
  void unsafe_arena_set_allocated_reaction(
      ::SessionProtos::DataMessage_Reaction* reaction);
  ::SessionProtos::DataMessage_Reaction* unsafe_arena_release_reaction();

  // optional .SessionProtos.LokiProfile profile = 101;
  bool has_profile() const;
  private:
  bool _internal_has_profile() const;
  public:
  void clear_profile();
  const ::SessionProtos::LokiProfile& profile() const;
  PROTOBUF_NODISCARD ::SessionProtos::LokiProfile* release_profile();
  ::SessionProtos::LokiProfile* mutable_profile();
  void set_allocated_profile(::SessionProtos::LokiProfile* profile);
  private:
  const ::SessionProtos::LokiProfile& _internal_profile() const;
  ::SessionProtos::LokiProfile* _internal_mutable_profile();
  public:
  void unsafe_arena_set_allocated_profile(
      ::SessionProtos::LokiProfile* profile);
  ::SessionProtos::LokiProfile* unsafe_arena_release_profile();

  // optional .SessionProtos.DataMessage.OpenGroupInvitation openGroupInvitation = 102;
  bool has_opengroupinvitation() const;
  private:
  bool _internal_has_opengroupinvitation() const;
  public:
  void clear_opengroupinvitation();
  const ::SessionProtos::DataMessage_OpenGroupInvitation& opengroupinvitation() const;
  PROTOBUF_NODISCARD ::SessionProtos::DataMessage_OpenGroupInvitation* release_opengroupinvitation();
  ::SessionProtos::DataMessage_OpenGroupInvitation* mutable_opengroupinvitation();
  void set_allocated_opengroupinvitation(::SessionProtos::DataMessage_OpenGroupInvitation* opengroupinvitation);
  private:
  const ::SessionProtos::DataMessage_OpenGroupInvitation& _internal_opengroupinvitation() const;
  ::SessionProtos::DataMessage_OpenGroupInvitation* _internal_mutable_opengroupinvitation();
  public:
  void unsafe_arena_set_allocated_opengroupinvitation(
      ::SessionProtos::DataMessage_OpenGroupInvitation* opengroupinvitation);
  ::SessionProtos::DataMessage_OpenGroupInvitation* unsafe_arena_release_opengroupinvitation();

  // optional .SessionProtos.GroupUpdateMessage groupUpdateMessage = 120;
  bool has_groupupdatemessage() const;
  private:
  bool _internal_has_groupupdatemessage() const;
  public:
  void clear_groupupdatemessage();
  const ::SessionProtos::GroupUpdateMessage& groupupdatemessage() const;
  PROTOBUF_NODISCARD ::SessionProtos::GroupUpdateMessage* release_groupupdatemessage();
  ::SessionProtos::GroupUpdateMessage* mutable_groupupdatemessage();
  void set_allocated_groupupdatemessage(::SessionProtos::GroupUpdateMessage* groupupdatemessage);
  private:
  const ::SessionProtos::GroupUpdateMessage& _internal_groupupdatemessage() const;
  ::SessionProtos::GroupUpdateMessage* _internal_mutable_groupupdatemessage();
  public:
  void unsafe_arena_set_allocated_groupupdatemessage(
      ::SessionProtos::GroupUpdateMessage* groupupdatemessage);
  ::SessionProtos::GroupUpdateMessage* unsafe_arena_release_groupupdatemessage();

  // optional uint64 timestamp = 7;
  bool has_timestamp() const;
  private:
  bool _internal_has_timestamp() const;
  public:
  void clear_timestamp();
  uint64_t timestamp() const;
  void set_timestamp(uint64_t value);
  private:
  uint64_t _internal_timestamp() const;
  void _internal_set_timestamp(uint64_t value);
  public:

  // optional uint32 flags = 4;
  bool has_flags() const;
  private:
  bool _internal_has_flags() const;
  public:
  void clear_flags();
  uint32_t flags() const;
  void set_flags(uint32_t value);
  private:
  uint32_t _internal_flags() const;
  void _internal_set_flags(uint32_t value);
  public:

  // optional bool blocksCommunityMessageRequests = 106;
  bool has_blockscommunitymessagerequests() const;
  private:
  bool _internal_has_blockscommunitymessagerequests() const;
  public:
  void clear_blockscommunitymessagerequests();
  bool blockscommunitymessagerequests() const;
  void set_blockscommunitymessagerequests(bool value);
  private:
  bool _internal_blockscommunitymessagerequests() const;
  void _internal_set_blockscommunitymessagerequests(bool value);
  public:

  // @@protoc_insertion_point(class_scope:SessionProtos.DataMessage)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SessionProtos::AttachmentPointer > attachments_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SessionProtos::DataMessage_Preview > preview_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr body_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr profilekey_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr synctarget_;
    ::SessionProtos::DataMessage_Quote* quote_;
    ::SessionProtos::DataMessage_Reaction* reaction_;
    ::SessionProtos::LokiProfile* profile_;
    ::SessionProtos::DataMessage_OpenGroupInvitation* opengroupinvitation_;
    ::SessionProtos::GroupUpdateMessage* groupupdatemessage_;
    uint64_t timestamp_;
    uint32_t flags_;
    bool blockscommunitymessagerequests_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_SessionProtos_2eproto;
};
// -------------------------------------------------------------------

class ReceiptMessage final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:SessionProtos.ReceiptMessage) */ {
 public:
  inline ReceiptMessage() : ReceiptMessage(nullptr) {}
  ~ReceiptMessage() override;
  explicit PROTOBUF_CONSTEXPR ReceiptMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline ReceiptMessage& operator=(const ReceiptMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline ReceiptMessage& operator=(ReceiptMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const ReceiptMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const ReceiptMessage* internal_default_instance() {
    return reinterpret_cast<const ReceiptMessage*>(
               &_ReceiptMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;

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

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

  ReceiptMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ReceiptMessage>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const ReceiptMessage& from);
  void MergeFrom(const ReceiptMessage& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ReceiptMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SessionProtos.ReceiptMessage";
  }
  protected:
  explicit ReceiptMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

  typedef ReceiptMessage_Type Type;
  static constexpr Type DELIVERY =
    ReceiptMessage_Type_DELIVERY;
  static constexpr Type READ =
    ReceiptMessage_Type_READ;
  static inline bool Type_IsValid(int value) {
    return ReceiptMessage_Type_IsValid(value);
  }
  static constexpr Type Type_MIN =
    ReceiptMessage_Type_Type_MIN;
  static constexpr Type Type_MAX =
    ReceiptMessage_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE =
    ReceiptMessage_Type_Type_ARRAYSIZE;
  template<typename T>
  static inline const std::string& Type_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Type>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Type_Name.");
    return ReceiptMessage_Type_Name(enum_t_value);
  }
  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Type* value) {
    return ReceiptMessage_Type_Parse(name, value);
  }

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

  enum : int {
    kTimestampFieldNumber = 2,
    kTypeFieldNumber = 1,
  };
  // repeated uint64 timestamp = 2;
  int timestamp_size() const;
  private:
  int _internal_timestamp_size() const;
  public:
  void clear_timestamp();
  private:
  uint64_t _internal_timestamp(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
      _internal_timestamp() const;
  void _internal_add_timestamp(uint64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
      _internal_mutable_timestamp();
  public:
  uint64_t timestamp(int index) const;
  void set_timestamp(int index, uint64_t value);
  void add_timestamp(uint64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
      timestamp() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
      mutable_timestamp();

  // required .SessionProtos.ReceiptMessage.Type type = 1;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::SessionProtos::ReceiptMessage_Type type() const;
  void set_type(::SessionProtos::ReceiptMessage_Type value);
  private:
  ::SessionProtos::ReceiptMessage_Type _internal_type() const;
  void _internal_set_type(::SessionProtos::ReceiptMessage_Type value);
  public:

  // @@protoc_insertion_point(class_scope:SessionProtos.ReceiptMessage)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t > timestamp_;
    int type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_SessionProtos_2eproto;
};
// -------------------------------------------------------------------

class AttachmentPointer final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:SessionProtos.AttachmentPointer) */ {
 public:
  inline AttachmentPointer() : AttachmentPointer(nullptr) {}
  ~AttachmentPointer() override;
  explicit PROTOBUF_CONSTEXPR AttachmentPointer(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline AttachmentPointer& operator=(const AttachmentPointer& from) {
    CopyFrom(from);
    return *this;
  }
  inline AttachmentPointer& operator=(AttachmentPointer&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const AttachmentPointer& default_instance() {
    return *internal_default_instance();
  }
  static inline const AttachmentPointer* internal_default_instance() {
    return reinterpret_cast<const AttachmentPointer*>(
               &_AttachmentPointer_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    16;

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

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

  AttachmentPointer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AttachmentPointer>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const AttachmentPointer& from);
  void MergeFrom(const AttachmentPointer& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(AttachmentPointer* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SessionProtos.AttachmentPointer";
  }
  protected:
  explicit AttachmentPointer(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

  typedef AttachmentPointer_Flags Flags;
  static constexpr Flags VOICE_MESSAGE =
    AttachmentPointer_Flags_VOICE_MESSAGE;
  static inline bool Flags_IsValid(int value) {
    return AttachmentPointer_Flags_IsValid(value);
  }
  static constexpr Flags Flags_MIN =
    AttachmentPointer_Flags_Flags_MIN;
  static constexpr Flags Flags_MAX =
    AttachmentPointer_Flags_Flags_MAX;
  static constexpr int Flags_ARRAYSIZE =
    AttachmentPointer_Flags_Flags_ARRAYSIZE;
  template<typename T>
  static inline const std::string& Flags_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Flags>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Flags_Name.");
    return AttachmentPointer_Flags_Name(enum_t_value);
  }
  static inline bool Flags_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Flags* value) {
    return AttachmentPointer_Flags_Parse(name, value);
  }

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

  enum : int {
    kContentTypeFieldNumber = 2,
    kKeyFieldNumber = 3,
    kThumbnailFieldNumber = 5,
    kDigestFieldNumber = 6,
    kFileNameFieldNumber = 7,
    kCaptionFieldNumber = 11,
    kUrlFieldNumber = 101,
    kIdFieldNumber = 1,
    kSizeFieldNumber = 4,
    kFlagsFieldNumber = 8,
    kWidthFieldNumber = 9,
    kHeightFieldNumber = 10,
  };
  // optional string contentType = 2;
  bool has_contenttype() const;
  private:
  bool _internal_has_contenttype() const;
  public:
  void clear_contenttype();
  const std::string& contenttype() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_contenttype(ArgT0&& arg0, ArgT... args);
  std::string* mutable_contenttype();
  PROTOBUF_NODISCARD std::string* release_contenttype();
  void set_allocated_contenttype(std::string* contenttype);
  private:
  const std::string& _internal_contenttype() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_contenttype(const std::string& value);
  std::string* _internal_mutable_contenttype();
  public:

  // optional bytes key = 3;
  bool has_key() const;
  private:
  bool _internal_has_key() const;
  public:
  void clear_key();
  const std::string& key() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_key(ArgT0&& arg0, ArgT... args);
  std::string* mutable_key();
  PROTOBUF_NODISCARD std::string* release_key();
  void set_allocated_key(std::string* key);
  private:
  const std::string& _internal_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value);
  std::string* _internal_mutable_key();
  public:

  // optional bytes thumbnail = 5;
  bool has_thumbnail() const;
  private:
  bool _internal_has_thumbnail() const;
  public:
  void clear_thumbnail();
  const std::string& thumbnail() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_thumbnail(ArgT0&& arg0, ArgT... args);
  std::string* mutable_thumbnail();
  PROTOBUF_NODISCARD std::string* release_thumbnail();
  void set_allocated_thumbnail(std::string* thumbnail);
  private:
  const std::string& _internal_thumbnail() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnail(const std::string& value);
  std::string* _internal_mutable_thumbnail();
  public:

  // optional bytes digest = 6;
  bool has_digest() const;
  private:
  bool _internal_has_digest() const;
  public:
  void clear_digest();
  const std::string& digest() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_digest(ArgT0&& arg0, ArgT... args);
  std::string* mutable_digest();
  PROTOBUF_NODISCARD std::string* release_digest();
  void set_allocated_digest(std::string* digest);
  private:
  const std::string& _internal_digest() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_digest(const std::string& value);
  std::string* _internal_mutable_digest();
  public:

  // optional string fileName = 7;
  bool has_filename() const;
  private:
  bool _internal_has_filename() const;
  public:
  void clear_filename();
  const std::string& filename() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_filename(ArgT0&& arg0, ArgT... args);
  std::string* mutable_filename();
  PROTOBUF_NODISCARD std::string* release_filename();
  void set_allocated_filename(std::string* filename);
  private:
  const std::string& _internal_filename() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_filename(const std::string& value);
  std::string* _internal_mutable_filename();
  public:

  // optional string caption = 11;
  bool has_caption() const;
  private:
  bool _internal_has_caption() const;
  public:
  void clear_caption();
  const std::string& caption() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_caption(ArgT0&& arg0, ArgT... args);
  std::string* mutable_caption();
  PROTOBUF_NODISCARD std::string* release_caption();
  void set_allocated_caption(std::string* caption);
  private:
  const std::string& _internal_caption() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_caption(const std::string& value);
  std::string* _internal_mutable_caption();
  public:

  // optional string url = 101;
  bool has_url() const;
  private:
  bool _internal_has_url() const;
  public:
  void clear_url();
  const std::string& url() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_url(ArgT0&& arg0, ArgT... args);
  std::string* mutable_url();
  PROTOBUF_NODISCARD std::string* release_url();
  void set_allocated_url(std::string* url);
  private:
  const std::string& _internal_url() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value);
  std::string* _internal_mutable_url();
  public:

  // required fixed64 id = 1;
  bool has_id() const;
  private:
  bool _internal_has_id() const;
  public:
  void clear_id();
  uint64_t id() const;
  void set_id(uint64_t value);
  private:
  uint64_t _internal_id() const;
  void _internal_set_id(uint64_t value);
  public:

  // optional uint32 size = 4;
  bool has_size() const;
  private:
  bool _internal_has_size() const;
  public:
  void clear_size();
  uint32_t size() const;
  void set_size(uint32_t value);
  private:
  uint32_t _internal_size() const;
  void _internal_set_size(uint32_t value);
  public:

  // optional uint32 flags = 8;
  bool has_flags() const;
  private:
  bool _internal_has_flags() const;
  public:
  void clear_flags();
  uint32_t flags() const;
  void set_flags(uint32_t value);
  private:
  uint32_t _internal_flags() const;
  void _internal_set_flags(uint32_t value);
  public:

  // optional uint32 width = 9;
  bool has_width() const;
  private:
  bool _internal_has_width() const;
  public:
  void clear_width();
  uint32_t width() const;
  void set_width(uint32_t value);
  private:
  uint32_t _internal_width() const;
  void _internal_set_width(uint32_t value);
  public:

  // optional uint32 height = 10;
  bool has_height() const;
  private:
  bool _internal_has_height() const;
  public:
  void clear_height();
  uint32_t height() const;
  void set_height(uint32_t value);
  private:
  uint32_t _internal_height() const;
  void _internal_set_height(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:SessionProtos.AttachmentPointer)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr contenttype_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnail_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr digest_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filename_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr caption_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
    uint64_t id_;
    uint32_t size_;
    uint32_t flags_;
    uint32_t width_;
    uint32_t height_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_SessionProtos_2eproto;
};
// -------------------------------------------------------------------

class SharedConfigMessage final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:SessionProtos.SharedConfigMessage) */ {
 public:
  inline SharedConfigMessage() : SharedConfigMessage(nullptr) {}
  ~SharedConfigMessage() override;
  explicit PROTOBUF_CONSTEXPR SharedConfigMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline SharedConfigMessage& operator=(const SharedConfigMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline SharedConfigMessage& operator=(SharedConfigMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const SharedConfigMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const SharedConfigMessage* internal_default_instance() {
    return reinterpret_cast<const SharedConfigMessage*>(
               &_SharedConfigMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    17;

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

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

  SharedConfigMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SharedConfigMessage>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SharedConfigMessage& from);
  void MergeFrom(const SharedConfigMessage& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SharedConfigMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SessionProtos.SharedConfigMessage";
  }
  protected:
  explicit SharedConfigMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

  typedef SharedConfigMessage_Kind Kind;
  static constexpr Kind USER_PROFILE =
    SharedConfigMessage_Kind_USER_PROFILE;
  static constexpr Kind CONTACTS =
    SharedConfigMessage_Kind_CONTACTS;
  static constexpr Kind CONVO_INFO_VOLATILE =
    SharedConfigMessage_Kind_CONVO_INFO_VOLATILE;
  static constexpr Kind USER_GROUPS =
    SharedConfigMessage_Kind_USER_GROUPS;
  static inline bool Kind_IsValid(int value) {
    return SharedConfigMessage_Kind_IsValid(value);
  }
  static constexpr Kind Kind_MIN =
    SharedConfigMessage_Kind_Kind_MIN;
  static constexpr Kind Kind_MAX =
    SharedConfigMessage_Kind_Kind_MAX;
  static constexpr int Kind_ARRAYSIZE =
    SharedConfigMessage_Kind_Kind_ARRAYSIZE;
  template<typename T>
  static inline const std::string& Kind_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Kind>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Kind_Name.");
    return SharedConfigMessage_Kind_Name(enum_t_value);
  }
  static inline bool Kind_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Kind* value) {
    return SharedConfigMessage_Kind_Parse(name, value);
  }

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

  enum : int {
    kDataFieldNumber = 3,
    kSeqnoFieldNumber = 2,
    kKindFieldNumber = 1,
  };
  // required bytes data = 3;
  bool has_data() const;
  private:
  bool _internal_has_data() const;
  public:
  void clear_data();
  const std::string& data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_data();
  PROTOBUF_NODISCARD std::string* release_data();
  void set_allocated_data(std::string* data);
  private:
  const std::string& _internal_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value);
  std::string* _internal_mutable_data();
  public:

  // required int64 seqno = 2;
  bool has_seqno() const;
  private:
  bool _internal_has_seqno() const;
  public:
  void clear_seqno();
  int64_t seqno() const;
  void set_seqno(int64_t value);
  private:
  int64_t _internal_seqno() const;
  void _internal_set_seqno(int64_t value);
  public:

  // required .SessionProtos.SharedConfigMessage.Kind kind = 1;
  bool has_kind() const;
  private:
  bool _internal_has_kind() const;
  public:
  void clear_kind();
  ::SessionProtos::SharedConfigMessage_Kind kind() const;
  void set_kind(::SessionProtos::SharedConfigMessage_Kind value);
  private:
  ::SessionProtos::SharedConfigMessage_Kind _internal_kind() const;
  void _internal_set_kind(::SessionProtos::SharedConfigMessage_Kind value);
  public:

  // @@protoc_insertion_point(class_scope:SessionProtos.SharedConfigMessage)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
    int64_t seqno_;
    int kind_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_SessionProtos_2eproto;
};
// -------------------------------------------------------------------

class GroupUpdateMessage final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:SessionProtos.GroupUpdateMessage) */ {
 public:
  inline GroupUpdateMessage() : GroupUpdateMessage(nullptr) {}
  ~GroupUpdateMessage() override;
  explicit PROTOBUF_CONSTEXPR GroupUpdateMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline GroupUpdateMessage& operator=(const GroupUpdateMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline GroupUpdateMessage& operator=(GroupUpdateMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GroupUpdateMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const GroupUpdateMessage* internal_default_instance() {
    return reinterpret_cast<const GroupUpdateMessage*>(
               &_GroupUpdateMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    18;

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

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

  GroupUpdateMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GroupUpdateMessage>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const GroupUpdateMessage& from);
  void MergeFrom(const GroupUpdateMessage& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(GroupUpdateMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SessionProtos.GroupUpdateMessage";
  }
  protected:
  explicit GroupUpdateMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kInviteMessageFieldNumber = 1,
    kInfoChangeMessageFieldNumber = 2,
    kMemberChangeMessageFieldNumber = 3,
    kPromoteMessageFieldNumber = 4,
    kMemberLeftMessageFieldNumber = 5,
    kInviteResponseFieldNumber = 6,
    kDeleteMemberContentFieldNumber = 7,
    kMemberLeftNotificationMessageFieldNumber = 8,
  };
  // optional .SessionProtos.GroupUpdateInviteMessage inviteMessage = 1;
  bool has_invitemessage() const;
  private:
  bool _internal_has_invitemessage() const;
  public:
  void clear_invitemessage();
  const ::SessionProtos::GroupUpdateInviteMessage& invitemessage() const;
  PROTOBUF_NODISCARD ::SessionProtos::GroupUpdateInviteMessage* release_invitemessage();
  ::SessionProtos::GroupUpdateInviteMessage* mutable_invitemessage();
  void set_allocated_invitemessage(::SessionProtos::GroupUpdateInviteMessage* invitemessage);
  private:
  const ::SessionProtos::GroupUpdateInviteMessage& _internal_invitemessage() const;
  ::SessionProtos::GroupUpdateInviteMessage* _internal_mutable_invitemessage();
  public:
  void unsafe_arena_set_allocated_invitemessage(
      ::SessionProtos::GroupUpdateInviteMessage* invitemessage);
  ::SessionProtos::GroupUpdateInviteMessage* unsafe_arena_release_invitemessage();

  // optional .SessionProtos.GroupUpdateInfoChangeMessage infoChangeMessage = 2;
  bool has_infochangemessage() const;
  private:
  bool _internal_has_infochangemessage() const;
  public:
  void clear_infochangemessage();
  const ::SessionProtos::GroupUpdateInfoChangeMessage& infochangemessage() const;
  PROTOBUF_NODISCARD ::SessionProtos::GroupUpdateInfoChangeMessage* release_infochangemessage();
  ::SessionProtos::GroupUpdateInfoChangeMessage* mutable_infochangemessage();
  void set_allocated_infochangemessage(::SessionProtos::GroupUpdateInfoChangeMessage* infochangemessage);
  private:
  const ::SessionProtos::GroupUpdateInfoChangeMessage& _internal_infochangemessage() const;
  ::SessionProtos::GroupUpdateInfoChangeMessage* _internal_mutable_infochangemessage();
  public:
  void unsafe_arena_set_allocated_infochangemessage(
      ::SessionProtos::GroupUpdateInfoChangeMessage* infochangemessage);
  ::SessionProtos::GroupUpdateInfoChangeMessage* unsafe_arena_release_infochangemessage();

  // optional .SessionProtos.GroupUpdateMemberChangeMessage memberChangeMessage = 3;
  bool has_memberchangemessage() const;
  private:
  bool _internal_has_memberchangemessage() const;
  public:
  void clear_memberchangemessage();
  const ::SessionProtos::GroupUpdateMemberChangeMessage& memberchangemessage() const;
  PROTOBUF_NODISCARD ::SessionProtos::GroupUpdateMemberChangeMessage* release_memberchangemessage();
  ::SessionProtos::GroupUpdateMemberChangeMessage* mutable_memberchangemessage();
  void set_allocated_memberchangemessage(::SessionProtos::GroupUpdateMemberChangeMessage* memberchangemessage);
  private:
  const ::SessionProtos::GroupUpdateMemberChangeMessage& _internal_memberchangemessage() const;
  ::SessionProtos::GroupUpdateMemberChangeMessage* _internal_mutable_memberchangemessage();
  public:
  void unsafe_arena_set_allocated_memberchangemessage(
      ::SessionProtos::GroupUpdateMemberChangeMessage* memberchangemessage);
  ::SessionProtos::GroupUpdateMemberChangeMessage* unsafe_arena_release_memberchangemessage();

  // optional .SessionProtos.GroupUpdatePromoteMessage promoteMessage = 4;
  bool has_promotemessage() const;
  private:
  bool _internal_has_promotemessage() const;
  public:
  void clear_promotemessage();
  const ::SessionProtos::GroupUpdatePromoteMessage& promotemessage() const;
  PROTOBUF_NODISCARD ::SessionProtos::GroupUpdatePromoteMessage* release_promotemessage();
  ::SessionProtos::GroupUpdatePromoteMessage* mutable_promotemessage();
  void set_allocated_promotemessage(::SessionProtos::GroupUpdatePromoteMessage* promotemessage);
  private:
  const ::SessionProtos::GroupUpdatePromoteMessage& _internal_promotemessage() const;
  ::SessionProtos::GroupUpdatePromoteMessage* _internal_mutable_promotemessage();
  public:
  void unsafe_arena_set_allocated_promotemessage(
      ::SessionProtos::GroupUpdatePromoteMessage* promotemessage);
  ::SessionProtos::GroupUpdatePromoteMessage* unsafe_arena_release_promotemessage();

  // optional .SessionProtos.GroupUpdateMemberLeftMessage memberLeftMessage = 5;
  bool has_memberleftmessage() const;
  private:
  bool _internal_has_memberleftmessage() const;
  public:
  void clear_memberleftmessage();
  const ::SessionProtos::GroupUpdateMemberLeftMessage& memberleftmessage() const;
  PROTOBUF_NODISCARD ::SessionProtos::GroupUpdateMemberLeftMessage* release_memberleftmessage();
  ::SessionProtos::GroupUpdateMemberLeftMessage* mutable_memberleftmessage();
  void set_allocated_memberleftmessage(::SessionProtos::GroupUpdateMemberLeftMessage* memberleftmessage);
  private:
  const ::SessionProtos::GroupUpdateMemberLeftMessage& _internal_memberleftmessage() const;
  ::SessionProtos::GroupUpdateMemberLeftMessage* _internal_mutable_memberleftmessage();
  public:
  void unsafe_arena_set_allocated_memberleftmessage(
      ::SessionProtos::GroupUpdateMemberLeftMessage* memberleftmessage);
  ::SessionProtos::GroupUpdateMemberLeftMessage* unsafe_arena_release_memberleftmessage();

  // optional .SessionProtos.GroupUpdateInviteResponseMessage inviteResponse = 6;
  bool has_inviteresponse() const;
  private:
  bool _internal_has_inviteresponse() const;
  public:
  void clear_inviteresponse();
  const ::SessionProtos::GroupUpdateInviteResponseMessage& inviteresponse() const;
  PROTOBUF_NODISCARD ::SessionProtos::GroupUpdateInviteResponseMessage* release_inviteresponse();
  ::SessionProtos::GroupUpdateInviteResponseMessage* mutable_inviteresponse();
  void set_allocated_inviteresponse(::SessionProtos::GroupUpdateInviteResponseMessage* inviteresponse);
  private:
  const ::SessionProtos::GroupUpdateInviteResponseMessage& _internal_inviteresponse() const;
  ::SessionProtos::GroupUpdateInviteResponseMessage* _internal_mutable_inviteresponse();
  public:
  void unsafe_arena_set_allocated_inviteresponse(
      ::SessionProtos::GroupUpdateInviteResponseMessage* inviteresponse);
  ::SessionProtos::GroupUpdateInviteResponseMessage* unsafe_arena_release_inviteresponse();

  // optional .SessionProtos.GroupUpdateDeleteMemberContentMessage deleteMemberContent = 7;
  bool has_deletemembercontent() const;
  private:
  bool _internal_has_deletemembercontent() const;
  public:
  void clear_deletemembercontent();
  const ::SessionProtos::GroupUpdateDeleteMemberContentMessage& deletemembercontent() const;
  PROTOBUF_NODISCARD ::SessionProtos::GroupUpdateDeleteMemberContentMessage* release_deletemembercontent();
  ::SessionProtos::GroupUpdateDeleteMemberContentMessage* mutable_deletemembercontent();
  void set_allocated_deletemembercontent(::SessionProtos::GroupUpdateDeleteMemberContentMessage* deletemembercontent);
  private:
  const ::SessionProtos::GroupUpdateDeleteMemberContentMessage& _internal_deletemembercontent() const;
  ::SessionProtos::GroupUpdateDeleteMemberContentMessage* _internal_mutable_deletemembercontent();
  public:
  void unsafe_arena_set_allocated_deletemembercontent(
      ::SessionProtos::GroupUpdateDeleteMemberContentMessage* deletemembercontent);
  ::SessionProtos::GroupUpdateDeleteMemberContentMessage* unsafe_arena_release_deletemembercontent();

  // optional .SessionProtos.GroupUpdateMemberLeftNotificationMessage memberLeftNotificationMessage = 8;
  bool has_memberleftnotificationmessage() const;
  private:
  bool _internal_has_memberleftnotificationmessage() const;
  public:
  void clear_memberleftnotificationmessage();
  const ::SessionProtos::GroupUpdateMemberLeftNotificationMessage& memberleftnotificationmessage() const;
  PROTOBUF_NODISCARD ::SessionProtos::GroupUpdateMemberLeftNotificationMessage* release_memberleftnotificationmessage();
  ::SessionProtos::GroupUpdateMemberLeftNotificationMessage* mutable_memberleftnotificationmessage();
  void set_allocated_memberleftnotificationmessage(::SessionProtos::GroupUpdateMemberLeftNotificationMessage* memberleftnotificationmessage);
  private:
  const ::SessionProtos::GroupUpdateMemberLeftNotificationMessage& _internal_memberleftnotificationmessage() const;
  ::SessionProtos::GroupUpdateMemberLeftNotificationMessage* _internal_mutable_memberleftnotificationmessage();
  public:
  void unsafe_arena_set_allocated_memberleftnotificationmessage(
      ::SessionProtos::GroupUpdateMemberLeftNotificationMessage* memberleftnotificationmessage);
  ::SessionProtos::GroupUpdateMemberLeftNotificationMessage* unsafe_arena_release_memberleftnotificationmessage();

  // @@protoc_insertion_point(class_scope:SessionProtos.GroupUpdateMessage)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::SessionProtos::GroupUpdateInviteMessage* invitemessage_;
    ::SessionProtos::GroupUpdateInfoChangeMessage* infochangemessage_;
    ::SessionProtos::GroupUpdateMemberChangeMessage* memberchangemessage_;
    ::SessionProtos::GroupUpdatePromoteMessage* promotemessage_;
    ::SessionProtos::GroupUpdateMemberLeftMessage* memberleftmessage_;
    ::SessionProtos::GroupUpdateInviteResponseMessage* inviteresponse_;
    ::SessionProtos::GroupUpdateDeleteMemberContentMessage* deletemembercontent_;
    ::SessionProtos::GroupUpdateMemberLeftNotificationMessage* memberleftnotificationmessage_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_SessionProtos_2eproto;
};
// -------------------------------------------------------------------

class GroupUpdateInviteMessage final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:SessionProtos.GroupUpdateInviteMessage) */ {
 public:
  inline GroupUpdateInviteMessage() : GroupUpdateInviteMessage(nullptr) {}
  ~GroupUpdateInviteMessage() override;
  explicit PROTOBUF_CONSTEXPR GroupUpdateInviteMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline GroupUpdateInviteMessage& operator=(const GroupUpdateInviteMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline GroupUpdateInviteMessage& operator=(GroupUpdateInviteMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GroupUpdateInviteMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const GroupUpdateInviteMessage* internal_default_instance() {
    return reinterpret_cast<const GroupUpdateInviteMessage*>(
               &_GroupUpdateInviteMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    19;

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

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

  GroupUpdateInviteMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GroupUpdateInviteMessage>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const GroupUpdateInviteMessage& from);
  void MergeFrom(const GroupUpdateInviteMessage& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(GroupUpdateInviteMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SessionProtos.GroupUpdateInviteMessage";
  }
  protected:
  explicit GroupUpdateInviteMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kGroupSessionIdFieldNumber = 1,
    kNameFieldNumber = 2,
    kMemberAuthDataFieldNumber = 3,
    kAdminSignatureFieldNumber = 4,
  };
  // required string groupSessionId = 1;
  bool has_groupsessionid() const;
  private:
  bool _internal_has_groupsessionid() const;
  public:
  void clear_groupsessionid();
  const std::string& groupsessionid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_groupsessionid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_groupsessionid();
  PROTOBUF_NODISCARD std::string* release_groupsessionid();
  void set_allocated_groupsessionid(std::string* groupsessionid);
  private:
  const std::string& _internal_groupsessionid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_groupsessionid(const std::string& value);
  std::string* _internal_mutable_groupsessionid();
  public:

  // required string name = 2;
  bool has_name() const;
  private:
  bool _internal_has_name() const;
  public:
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // required bytes memberAuthData = 3;
  bool has_memberauthdata() const;
  private:
  bool _internal_has_memberauthdata() const;
  public:
  void clear_memberauthdata();
  const std::string& memberauthdata() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_memberauthdata(ArgT0&& arg0, ArgT... args);
  std::string* mutable_memberauthdata();
  PROTOBUF_NODISCARD std::string* release_memberauthdata();
  void set_allocated_memberauthdata(std::string* memberauthdata);
  private:
  const std::string& _internal_memberauthdata() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_memberauthdata(const std::string& value);
  std::string* _internal_mutable_memberauthdata();
  public:

  // required bytes adminSignature = 4;
  bool has_adminsignature() const;
  private:
  bool _internal_has_adminsignature() const;
  public:
  void clear_adminsignature();
  const std::string& adminsignature() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_adminsignature(ArgT0&& arg0, ArgT... args);
  std::string* mutable_adminsignature();
  PROTOBUF_NODISCARD std::string* release_adminsignature();
  void set_allocated_adminsignature(std::string* adminsignature);
  private:
  const std::string& _internal_adminsignature() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_adminsignature(const std::string& value);
  std::string* _internal_mutable_adminsignature();
  public:

  // @@protoc_insertion_point(class_scope:SessionProtos.GroupUpdateInviteMessage)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr groupsessionid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr memberauthdata_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr adminsignature_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_SessionProtos_2eproto;
};
// -------------------------------------------------------------------

class GroupUpdatePromoteMessage final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:SessionProtos.GroupUpdatePromoteMessage) */ {
 public:
  inline GroupUpdatePromoteMessage() : GroupUpdatePromoteMessage(nullptr) {}
  ~GroupUpdatePromoteMessage() override;
  explicit PROTOBUF_CONSTEXPR GroupUpdatePromoteMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline GroupUpdatePromoteMessage& operator=(const GroupUpdatePromoteMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline GroupUpdatePromoteMessage& operator=(GroupUpdatePromoteMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GroupUpdatePromoteMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const GroupUpdatePromoteMessage* internal_default_instance() {
    return reinterpret_cast<const GroupUpdatePromoteMessage*>(
               &_GroupUpdatePromoteMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    20;

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

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

  GroupUpdatePromoteMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GroupUpdatePromoteMessage>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const GroupUpdatePromoteMessage& from);
  void MergeFrom(const GroupUpdatePromoteMessage& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(GroupUpdatePromoteMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SessionProtos.GroupUpdatePromoteMessage";
  }
  protected:
  explicit GroupUpdatePromoteMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kGroupIdentitySeedFieldNumber = 1,
    kNameFieldNumber = 2,
  };
  // required bytes groupIdentitySeed = 1;
  bool has_groupidentityseed() const;
  private:
  bool _internal_has_groupidentityseed() const;
  public:
  void clear_groupidentityseed();
  const std::string& groupidentityseed() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_groupidentityseed(ArgT0&& arg0, ArgT... args);
  std::string* mutable_groupidentityseed();
  PROTOBUF_NODISCARD std::string* release_groupidentityseed();
  void set_allocated_groupidentityseed(std::string* groupidentityseed);
  private:
  const std::string& _internal_groupidentityseed() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_groupidentityseed(const std::string& value);
  std::string* _internal_mutable_groupidentityseed();
  public:

  // required string name = 2;
  bool has_name() const;
  private:
  bool _internal_has_name() const;
  public:
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // @@protoc_insertion_point(class_scope:SessionProtos.GroupUpdatePromoteMessage)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr groupidentityseed_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_SessionProtos_2eproto;
};
// -------------------------------------------------------------------

class GroupUpdateInfoChangeMessage final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:SessionProtos.GroupUpdateInfoChangeMessage) */ {
 public:
  inline GroupUpdateInfoChangeMessage() : GroupUpdateInfoChangeMessage(nullptr) {}
  ~GroupUpdateInfoChangeMessage() override;
  explicit PROTOBUF_CONSTEXPR GroupUpdateInfoChangeMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline GroupUpdateInfoChangeMessage& operator=(const GroupUpdateInfoChangeMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline GroupUpdateInfoChangeMessage& operator=(GroupUpdateInfoChangeMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GroupUpdateInfoChangeMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const GroupUpdateInfoChangeMessage* internal_default_instance() {
    return reinterpret_cast<const GroupUpdateInfoChangeMessage*>(
               &_GroupUpdateInfoChangeMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    21;

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

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

  GroupUpdateInfoChangeMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GroupUpdateInfoChangeMessage>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const GroupUpdateInfoChangeMessage& from);
  void MergeFrom(const GroupUpdateInfoChangeMessage& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(GroupUpdateInfoChangeMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SessionProtos.GroupUpdateInfoChangeMessage";
  }
  protected:
  explicit GroupUpdateInfoChangeMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

  typedef GroupUpdateInfoChangeMessage_Type Type;
  static constexpr Type NAME =
    GroupUpdateInfoChangeMessage_Type_NAME;
  static constexpr Type AVATAR =
    GroupUpdateInfoChangeMessage_Type_AVATAR;
  static constexpr Type DISAPPEARING_MESSAGES =
    GroupUpdateInfoChangeMessage_Type_DISAPPEARING_MESSAGES;
  static inline bool Type_IsValid(int value) {
    return GroupUpdateInfoChangeMessage_Type_IsValid(value);
  }
  static constexpr Type Type_MIN =
    GroupUpdateInfoChangeMessage_Type_Type_MIN;
  static constexpr Type Type_MAX =
    GroupUpdateInfoChangeMessage_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE =
    GroupUpdateInfoChangeMessage_Type_Type_ARRAYSIZE;
  template<typename T>
  static inline const std::string& Type_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Type>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Type_Name.");
    return GroupUpdateInfoChangeMessage_Type_Name(enum_t_value);
  }
  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Type* value) {
    return GroupUpdateInfoChangeMessage_Type_Parse(name, value);
  }

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

  enum : int {
    kUpdatedNameFieldNumber = 2,
    kAdminSignatureFieldNumber = 4,
    kUpdatedExpirationFieldNumber = 3,
    kTypeFieldNumber = 1,
  };
  // optional string updatedName = 2;
  bool has_updatedname() const;
  private:
  bool _internal_has_updatedname() const;
  public:
  void clear_updatedname();
  const std::string& updatedname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_updatedname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_updatedname();
  PROTOBUF_NODISCARD std::string* release_updatedname();
  void set_allocated_updatedname(std::string* updatedname);
  private:
  const std::string& _internal_updatedname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_updatedname(const std::string& value);
  std::string* _internal_mutable_updatedname();
  public:

  // required bytes adminSignature = 4;
  bool has_adminsignature() const;
  private:
  bool _internal_has_adminsignature() const;
  public:
  void clear_adminsignature();
  const std::string& adminsignature() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_adminsignature(ArgT0&& arg0, ArgT... args);
  std::string* mutable_adminsignature();
  PROTOBUF_NODISCARD std::string* release_adminsignature();
  void set_allocated_adminsignature(std::string* adminsignature);
  private:
  const std::string& _internal_adminsignature() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_adminsignature(const std::string& value);
  std::string* _internal_mutable_adminsignature();
  public:

  // optional uint32 updatedExpiration = 3;
  bool has_updatedexpiration() const;
  private:
  bool _internal_has_updatedexpiration() const;
  public:
  void clear_updatedexpiration();
  uint32_t updatedexpiration() const;
  void set_updatedexpiration(uint32_t value);
  private:
  uint32_t _internal_updatedexpiration() const;
  void _internal_set_updatedexpiration(uint32_t value);
  public:

  // required .SessionProtos.GroupUpdateInfoChangeMessage.Type type = 1;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::SessionProtos::GroupUpdateInfoChangeMessage_Type type() const;
  void set_type(::SessionProtos::GroupUpdateInfoChangeMessage_Type value);
  private:
  ::SessionProtos::GroupUpdateInfoChangeMessage_Type _internal_type() const;
  void _internal_set_type(::SessionProtos::GroupUpdateInfoChangeMessage_Type value);
  public:

  // @@protoc_insertion_point(class_scope:SessionProtos.GroupUpdateInfoChangeMessage)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr updatedname_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr adminsignature_;
    uint32_t updatedexpiration_;
    int type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_SessionProtos_2eproto;
};
// -------------------------------------------------------------------

class GroupUpdateMemberChangeMessage final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:SessionProtos.GroupUpdateMemberChangeMessage) */ {
 public:
  inline GroupUpdateMemberChangeMessage() : GroupUpdateMemberChangeMessage(nullptr) {}
  ~GroupUpdateMemberChangeMessage() override;
  explicit PROTOBUF_CONSTEXPR GroupUpdateMemberChangeMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline GroupUpdateMemberChangeMessage& operator=(const GroupUpdateMemberChangeMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline GroupUpdateMemberChangeMessage& operator=(GroupUpdateMemberChangeMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GroupUpdateMemberChangeMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const GroupUpdateMemberChangeMessage* internal_default_instance() {
    return reinterpret_cast<const GroupUpdateMemberChangeMessage*>(
               &_GroupUpdateMemberChangeMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    22;

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

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

  GroupUpdateMemberChangeMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GroupUpdateMemberChangeMessage>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const GroupUpdateMemberChangeMessage& from);
  void MergeFrom(const GroupUpdateMemberChangeMessage& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(GroupUpdateMemberChangeMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SessionProtos.GroupUpdateMemberChangeMessage";
  }
  protected:
  explicit GroupUpdateMemberChangeMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

  typedef GroupUpdateMemberChangeMessage_Type Type;
  static constexpr Type ADDED =
    GroupUpdateMemberChangeMessage_Type_ADDED;
  static constexpr Type REMOVED =
    GroupUpdateMemberChangeMessage_Type_REMOVED;
  static constexpr Type PROMOTED =
    GroupUpdateMemberChangeMessage_Type_PROMOTED;
  static inline bool Type_IsValid(int value) {
    return GroupUpdateMemberChangeMessage_Type_IsValid(value);
  }
  static constexpr Type Type_MIN =
    GroupUpdateMemberChangeMessage_Type_Type_MIN;
  static constexpr Type Type_MAX =
    GroupUpdateMemberChangeMessage_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE =
    GroupUpdateMemberChangeMessage_Type_Type_ARRAYSIZE;
  template<typename T>
  static inline const std::string& Type_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Type>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Type_Name.");
    return GroupUpdateMemberChangeMessage_Type_Name(enum_t_value);
  }
  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Type* value) {
    return GroupUpdateMemberChangeMessage_Type_Parse(name, value);
  }

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

  enum : int {
    kMemberSessionIdsFieldNumber = 2,
    kAdminSignatureFieldNumber = 4,
    kHistorySharedFieldNumber = 3,
    kTypeFieldNumber = 1,
  };
  // repeated string memberSessionIds = 2;
  int membersessionids_size() const;
  private:
  int _internal_membersessionids_size() const;
  public:
  void clear_membersessionids();
  const std::string& membersessionids(int index) const;
  std::string* mutable_membersessionids(int index);
  void set_membersessionids(int index, const std::string& value);
  void set_membersessionids(int index, std::string&& value);
  void set_membersessionids(int index, const char* value);
  void set_membersessionids(int index, const char* value, size_t size);
  std::string* add_membersessionids();
  void add_membersessionids(const std::string& value);
  void add_membersessionids(std::string&& value);
  void add_membersessionids(const char* value);
  void add_membersessionids(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& membersessionids() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_membersessionids();
  private:
  const std::string& _internal_membersessionids(int index) const;
  std::string* _internal_add_membersessionids();
  public:

  // required bytes adminSignature = 4;
  bool has_adminsignature() const;
  private:
  bool _internal_has_adminsignature() const;
  public:
  void clear_adminsignature();
  const std::string& adminsignature() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_adminsignature(ArgT0&& arg0, ArgT... args);
  std::string* mutable_adminsignature();
  PROTOBUF_NODISCARD std::string* release_adminsignature();
  void set_allocated_adminsignature(std::string* adminsignature);
  private:
  const std::string& _internal_adminsignature() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_adminsignature(const std::string& value);
  std::string* _internal_mutable_adminsignature();
  public:

  // optional bool historyShared = 3;
  bool has_historyshared() const;
  private:
  bool _internal_has_historyshared() const;
  public:
  void clear_historyshared();
  bool historyshared() const;
  void set_historyshared(bool value);
  private:
  bool _internal_historyshared() const;
  void _internal_set_historyshared(bool value);
  public:

  // required .SessionProtos.GroupUpdateMemberChangeMessage.Type type = 1;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::SessionProtos::GroupUpdateMemberChangeMessage_Type type() const;
  void set_type(::SessionProtos::GroupUpdateMemberChangeMessage_Type value);
  private:
  ::SessionProtos::GroupUpdateMemberChangeMessage_Type _internal_type() const;
  void _internal_set_type(::SessionProtos::GroupUpdateMemberChangeMessage_Type value);
  public:

  // @@protoc_insertion_point(class_scope:SessionProtos.GroupUpdateMemberChangeMessage)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> membersessionids_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr adminsignature_;
    bool historyshared_;
    int type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_SessionProtos_2eproto;
};
// -------------------------------------------------------------------

class GroupUpdateMemberLeftMessage final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:SessionProtos.GroupUpdateMemberLeftMessage) */ {
 public:
  inline GroupUpdateMemberLeftMessage() : GroupUpdateMemberLeftMessage(nullptr) {}
  ~GroupUpdateMemberLeftMessage() override;
  explicit PROTOBUF_CONSTEXPR GroupUpdateMemberLeftMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline GroupUpdateMemberLeftMessage& operator=(const GroupUpdateMemberLeftMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline GroupUpdateMemberLeftMessage& operator=(GroupUpdateMemberLeftMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GroupUpdateMemberLeftMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const GroupUpdateMemberLeftMessage* internal_default_instance() {
    return reinterpret_cast<const GroupUpdateMemberLeftMessage*>(
               &_GroupUpdateMemberLeftMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    23;

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

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

  GroupUpdateMemberLeftMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GroupUpdateMemberLeftMessage>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const GroupUpdateMemberLeftMessage& from);
  void MergeFrom(const GroupUpdateMemberLeftMessage& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(GroupUpdateMemberLeftMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SessionProtos.GroupUpdateMemberLeftMessage";
  }
  protected:
  explicit GroupUpdateMemberLeftMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  // @@protoc_insertion_point(class_scope:SessionProtos.GroupUpdateMemberLeftMessage)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_SessionProtos_2eproto;
};
// -------------------------------------------------------------------

class GroupUpdateMemberLeftNotificationMessage final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:SessionProtos.GroupUpdateMemberLeftNotificationMessage) */ {
 public:
  inline GroupUpdateMemberLeftNotificationMessage() : GroupUpdateMemberLeftNotificationMessage(nullptr) {}
  ~GroupUpdateMemberLeftNotificationMessage() override;
  explicit PROTOBUF_CONSTEXPR GroupUpdateMemberLeftNotificationMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline GroupUpdateMemberLeftNotificationMessage& operator=(const GroupUpdateMemberLeftNotificationMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline GroupUpdateMemberLeftNotificationMessage& operator=(GroupUpdateMemberLeftNotificationMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GroupUpdateMemberLeftNotificationMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const GroupUpdateMemberLeftNotificationMessage* internal_default_instance() {
    return reinterpret_cast<const GroupUpdateMemberLeftNotificationMessage*>(
               &_GroupUpdateMemberLeftNotificationMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    24;

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

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

  GroupUpdateMemberLeftNotificationMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GroupUpdateMemberLeftNotificationMessage>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const GroupUpdateMemberLeftNotificationMessage& from);
  void MergeFrom(const GroupUpdateMemberLeftNotificationMessage& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(GroupUpdateMemberLeftNotificationMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SessionProtos.GroupUpdateMemberLeftNotificationMessage";
  }
  protected:
  explicit GroupUpdateMemberLeftNotificationMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  // @@protoc_insertion_point(class_scope:SessionProtos.GroupUpdateMemberLeftNotificationMessage)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_SessionProtos_2eproto;
};
// -------------------------------------------------------------------

class GroupUpdateInviteResponseMessage final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:SessionProtos.GroupUpdateInviteResponseMessage) */ {
 public:
  inline GroupUpdateInviteResponseMessage() : GroupUpdateInviteResponseMessage(nullptr) {}
  ~GroupUpdateInviteResponseMessage() override;
  explicit PROTOBUF_CONSTEXPR GroupUpdateInviteResponseMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline GroupUpdateInviteResponseMessage& operator=(const GroupUpdateInviteResponseMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline GroupUpdateInviteResponseMessage& operator=(GroupUpdateInviteResponseMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GroupUpdateInviteResponseMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const GroupUpdateInviteResponseMessage* internal_default_instance() {
    return reinterpret_cast<const GroupUpdateInviteResponseMessage*>(
               &_GroupUpdateInviteResponseMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    25;

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

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

  GroupUpdateInviteResponseMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GroupUpdateInviteResponseMessage>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const GroupUpdateInviteResponseMessage& from);
  void MergeFrom(const GroupUpdateInviteResponseMessage& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(GroupUpdateInviteResponseMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SessionProtos.GroupUpdateInviteResponseMessage";
  }
  protected:
  explicit GroupUpdateInviteResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kIsApprovedFieldNumber = 1,
  };
  // required bool isApproved = 1;
  bool has_isapproved() const;
  private:
  bool _internal_has_isapproved() const;
  public:
  void clear_isapproved();
  bool isapproved() const;
  void set_isapproved(bool value);
  private:
  bool _internal_isapproved() const;
  void _internal_set_isapproved(bool value);
  public:

  // @@protoc_insertion_point(class_scope:SessionProtos.GroupUpdateInviteResponseMessage)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    bool isapproved_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_SessionProtos_2eproto;
};
// -------------------------------------------------------------------

class GroupUpdateDeleteMemberContentMessage final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:SessionProtos.GroupUpdateDeleteMemberContentMessage) */ {
 public:
  inline GroupUpdateDeleteMemberContentMessage() : GroupUpdateDeleteMemberContentMessage(nullptr) {}
  ~GroupUpdateDeleteMemberContentMessage() override;
  explicit PROTOBUF_CONSTEXPR GroupUpdateDeleteMemberContentMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline GroupUpdateDeleteMemberContentMessage& operator=(const GroupUpdateDeleteMemberContentMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline GroupUpdateDeleteMemberContentMessage& operator=(GroupUpdateDeleteMemberContentMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GroupUpdateDeleteMemberContentMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const GroupUpdateDeleteMemberContentMessage* internal_default_instance() {
    return reinterpret_cast<const GroupUpdateDeleteMemberContentMessage*>(
               &_GroupUpdateDeleteMemberContentMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    26;

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

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

  GroupUpdateDeleteMemberContentMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GroupUpdateDeleteMemberContentMessage>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const GroupUpdateDeleteMemberContentMessage& from);
  void MergeFrom(const GroupUpdateDeleteMemberContentMessage& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(GroupUpdateDeleteMemberContentMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SessionProtos.GroupUpdateDeleteMemberContentMessage";
  }
  protected:
  explicit GroupUpdateDeleteMemberContentMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kMemberSessionIdsFieldNumber = 1,
    kMessageHashesFieldNumber = 2,
    kAdminSignatureFieldNumber = 3,
  };
  // repeated string memberSessionIds = 1;
  int membersessionids_size() const;
  private:
  int _internal_membersessionids_size() const;
  public:
  void clear_membersessionids();
  const std::string& membersessionids(int index) const;
  std::string* mutable_membersessionids(int index);
  void set_membersessionids(int index, const std::string& value);
  void set_membersessionids(int index, std::string&& value);
  void set_membersessionids(int index, const char* value);
  void set_membersessionids(int index, const char* value, size_t size);
  std::string* add_membersessionids();
  void add_membersessionids(const std::string& value);
  void add_membersessionids(std::string&& value);
  void add_membersessionids(const char* value);
  void add_membersessionids(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& membersessionids() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_membersessionids();
  private:
  const std::string& _internal_membersessionids(int index) const;
  std::string* _internal_add_membersessionids();
  public:

  // repeated string messageHashes = 2;
  int messagehashes_size() const;
  private:
  int _internal_messagehashes_size() const;
  public:
  void clear_messagehashes();
  const std::string& messagehashes(int index) const;
  std::string* mutable_messagehashes(int index);
  void set_messagehashes(int index, const std::string& value);
  void set_messagehashes(int index, std::string&& value);
  void set_messagehashes(int index, const char* value);
  void set_messagehashes(int index, const char* value, size_t size);
  std::string* add_messagehashes();
  void add_messagehashes(const std::string& value);
  void add_messagehashes(std::string&& value);
  void add_messagehashes(const char* value);
  void add_messagehashes(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& messagehashes() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_messagehashes();
  private:
  const std::string& _internal_messagehashes(int index) const;
  std::string* _internal_add_messagehashes();
  public:

  // optional bytes adminSignature = 3;
  bool has_adminsignature() const;
  private:
  bool _internal_has_adminsignature() const;
  public:
  void clear_adminsignature();
  const std::string& adminsignature() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_adminsignature(ArgT0&& arg0, ArgT... args);
  std::string* mutable_adminsignature();
  PROTOBUF_NODISCARD std::string* release_adminsignature();
  void set_allocated_adminsignature(std::string* adminsignature);
  private:
  const std::string& _internal_adminsignature() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_adminsignature(const std::string& value);
  std::string* _internal_mutable_adminsignature();
  public:

  // @@protoc_insertion_point(class_scope:SessionProtos.GroupUpdateDeleteMemberContentMessage)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> membersessionids_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> messagehashes_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr adminsignature_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_SessionProtos_2eproto;
};
// -------------------------------------------------------------------

class ProProof final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:SessionProtos.ProProof) */ {
 public:
  inline ProProof() : ProProof(nullptr) {}
  ~ProProof() override;
  explicit PROTOBUF_CONSTEXPR ProProof(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline ProProof& operator=(const ProProof& from) {
    CopyFrom(from);
    return *this;
  }
  inline ProProof& operator=(ProProof&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const ProProof& default_instance() {
    return *internal_default_instance();
  }
  static inline const ProProof* internal_default_instance() {
    return reinterpret_cast<const ProProof*>(
               &_ProProof_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    27;

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

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

  ProProof* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ProProof>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const ProProof& from);
  void MergeFrom(const ProProof& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ProProof* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SessionProtos.ProProof";
  }
  protected:
  explicit ProProof(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kRevocationTagFieldNumber = 2,
    kRotatingPublicKeyFieldNumber = 3,
    kSigFieldNumber = 5,
    kExpiryUnixTsFieldNumber = 4,
    kVersionFieldNumber = 1,
  };
  // optional bytes revocationTag = 2;
  bool has_revocationtag() const;
  private:
  bool _internal_has_revocationtag() const;
  public:
  void clear_revocationtag();
  const std::string& revocationtag() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_revocationtag(ArgT0&& arg0, ArgT... args);
  std::string* mutable_revocationtag();
  PROTOBUF_NODISCARD std::string* release_revocationtag();
  void set_allocated_revocationtag(std::string* revocationtag);
  private:
  const std::string& _internal_revocationtag() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_revocationtag(const std::string& value);
  std::string* _internal_mutable_revocationtag();
  public:

  // optional bytes rotatingPublicKey = 3;
  bool has_rotatingpublickey() const;
  private:
  bool _internal_has_rotatingpublickey() const;
  public:
  void clear_rotatingpublickey();
  const std::string& rotatingpublickey() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_rotatingpublickey(ArgT0&& arg0, ArgT... args);
  std::string* mutable_rotatingpublickey();
  PROTOBUF_NODISCARD std::string* release_rotatingpublickey();
  void set_allocated_rotatingpublickey(std::string* rotatingpublickey);
  private:
  const std::string& _internal_rotatingpublickey() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_rotatingpublickey(const std::string& value);
  std::string* _internal_mutable_rotatingpublickey();
  public:

  // optional bytes sig = 5;
  bool has_sig() const;
  private:
  bool _internal_has_sig() const;
  public:
  void clear_sig();
  const std::string& sig() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_sig(ArgT0&& arg0, ArgT... args);
  std::string* mutable_sig();
  PROTOBUF_NODISCARD std::string* release_sig();
  void set_allocated_sig(std::string* sig);
  private:
  const std::string& _internal_sig() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sig(const std::string& value);
  std::string* _internal_mutable_sig();
  public:

  // optional uint64 expiryUnixTs = 4;
  bool has_expiryunixts() const;
  private:
  bool _internal_has_expiryunixts() const;
  public:
  void clear_expiryunixts();
  uint64_t expiryunixts() const;
  void set_expiryunixts(uint64_t value);
  private:
  uint64_t _internal_expiryunixts() const;
  void _internal_set_expiryunixts(uint64_t value);
  public:

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

  // @@protoc_insertion_point(class_scope:SessionProtos.ProProof)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr revocationtag_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rotatingpublickey_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sig_;
    uint64_t expiryunixts_;
    uint32_t version_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_SessionProtos_2eproto;
};
// -------------------------------------------------------------------

class ProMessage final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:SessionProtos.ProMessage) */ {
 public:
  inline ProMessage() : ProMessage(nullptr) {}
  ~ProMessage() override;
  explicit PROTOBUF_CONSTEXPR ProMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline ProMessage& operator=(const ProMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline ProMessage& operator=(ProMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const ProMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const ProMessage* internal_default_instance() {
    return reinterpret_cast<const ProMessage*>(
               &_ProMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    28;

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

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

  ProMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ProMessage>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const ProMessage& from);
  void MergeFrom(const ProMessage& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ProMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SessionProtos.ProMessage";
  }
  protected:
  explicit ProMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kProofFieldNumber = 1,
    kProfileBitsetFieldNumber = 2,
    kMsgBitsetFieldNumber = 3,
  };
  // optional .SessionProtos.ProProof proof = 1;
  bool has_proof() const;
  private:
  bool _internal_has_proof() const;
  public:
  void clear_proof();
  const ::SessionProtos::ProProof& proof() const;
  PROTOBUF_NODISCARD ::SessionProtos::ProProof* release_proof();
  ::SessionProtos::ProProof* mutable_proof();
  void set_allocated_proof(::SessionProtos::ProProof* proof);
  private:
  const ::SessionProtos::ProProof& _internal_proof() const;
  ::SessionProtos::ProProof* _internal_mutable_proof();
  public:
  void unsafe_arena_set_allocated_proof(
      ::SessionProtos::ProProof* proof);
  ::SessionProtos::ProProof* unsafe_arena_release_proof();

  // optional uint64 profileBitset = 2;
  bool has_profilebitset() const;
  private:
  bool _internal_has_profilebitset() const;
  public:
  void clear_profilebitset();
  uint64_t profilebitset() const;
  void set_profilebitset(uint64_t value);
  private:
  uint64_t _internal_profilebitset() const;
  void _internal_set_profilebitset(uint64_t value);
  public:

  // optional uint64 msgBitset = 3;
  bool has_msgbitset() const;
  private:
  bool _internal_has_msgbitset() const;
  public:
  void clear_msgbitset();
  uint64_t msgbitset() const;
  void set_msgbitset(uint64_t value);
  private:
  uint64_t _internal_msgbitset() const;
  void _internal_set_msgbitset(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:SessionProtos.ProMessage)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::SessionProtos::ProProof* proof_;
    uint64_t profilebitset_;
    uint64_t msgbitset_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_SessionProtos_2eproto;
};
// ===================================================================


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

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

// required .SessionProtos.Envelope.Type type = 1;
inline bool Envelope::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool Envelope::has_type() const {
  return _internal_has_type();
}
inline void Envelope::clear_type() {
  _impl_.type_ = 6;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline ::SessionProtos::Envelope_Type Envelope::_internal_type() const {
  return static_cast< ::SessionProtos::Envelope_Type >(_impl_.type_);
}
inline ::SessionProtos::Envelope_Type Envelope::type() const {
  // @@protoc_insertion_point(field_get:SessionProtos.Envelope.type)
  return _internal_type();
}
inline void Envelope::_internal_set_type(::SessionProtos::Envelope_Type value) {
  assert(::SessionProtos::Envelope_Type_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.type_ = value;
}
inline void Envelope::set_type(::SessionProtos::Envelope_Type value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:SessionProtos.Envelope.type)
}

// optional string source = 2;
inline bool Envelope::_internal_has_source() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Envelope::has_source() const {
  return _internal_has_source();
}
inline void Envelope::clear_source() {
  _impl_.source_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Envelope::source() const {
  // @@protoc_insertion_point(field_get:SessionProtos.Envelope.source)
  return _internal_source();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Envelope::set_source(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.source_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.Envelope.source)
}
inline std::string* Envelope::mutable_source() {
  std::string* _s = _internal_mutable_source();
  // @@protoc_insertion_point(field_mutable:SessionProtos.Envelope.source)
  return _s;
}
inline const std::string& Envelope::_internal_source() const {
  return _impl_.source_.Get();
}
inline void Envelope::_internal_set_source(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.source_.Set(value, GetArenaForAllocation());
}
inline std::string* Envelope::_internal_mutable_source() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.source_.Mutable(GetArenaForAllocation());
}
inline std::string* Envelope::release_source() {
  // @@protoc_insertion_point(field_release:SessionProtos.Envelope.source)
  if (!_internal_has_source()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.source_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.source_.IsDefault()) {
    _impl_.source_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Envelope::set_allocated_source(std::string* source) {
  if (source != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.source_.SetAllocated(source, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.source_.IsDefault()) {
    _impl_.source_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.Envelope.source)
}

// optional uint32 sourceDevice = 7;
inline bool Envelope::_internal_has_sourcedevice() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Envelope::has_sourcedevice() const {
  return _internal_has_sourcedevice();
}
inline void Envelope::clear_sourcedevice() {
  _impl_.sourcedevice_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t Envelope::_internal_sourcedevice() const {
  return _impl_.sourcedevice_;
}
inline uint32_t Envelope::sourcedevice() const {
  // @@protoc_insertion_point(field_get:SessionProtos.Envelope.sourceDevice)
  return _internal_sourcedevice();
}
inline void Envelope::_internal_set_sourcedevice(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.sourcedevice_ = value;
}
inline void Envelope::set_sourcedevice(uint32_t value) {
  _internal_set_sourcedevice(value);
  // @@protoc_insertion_point(field_set:SessionProtos.Envelope.sourceDevice)
}

// required uint64 timestamp = 5;
inline bool Envelope::_internal_has_timestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Envelope::has_timestamp() const {
  return _internal_has_timestamp();
}
inline void Envelope::clear_timestamp() {
  _impl_.timestamp_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint64_t Envelope::_internal_timestamp() const {
  return _impl_.timestamp_;
}
inline uint64_t Envelope::timestamp() const {
  // @@protoc_insertion_point(field_get:SessionProtos.Envelope.timestamp)
  return _internal_timestamp();
}
inline void Envelope::_internal_set_timestamp(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.timestamp_ = value;
}
inline void Envelope::set_timestamp(uint64_t value) {
  _internal_set_timestamp(value);
  // @@protoc_insertion_point(field_set:SessionProtos.Envelope.timestamp)
}

// optional bytes content = 8;
inline bool Envelope::_internal_has_content() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Envelope::has_content() const {
  return _internal_has_content();
}
inline void Envelope::clear_content() {
  _impl_.content_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Envelope::content() const {
  // @@protoc_insertion_point(field_get:SessionProtos.Envelope.content)
  return _internal_content();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Envelope::set_content(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.content_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.Envelope.content)
}
inline std::string* Envelope::mutable_content() {
  std::string* _s = _internal_mutable_content();
  // @@protoc_insertion_point(field_mutable:SessionProtos.Envelope.content)
  return _s;
}
inline const std::string& Envelope::_internal_content() const {
  return _impl_.content_.Get();
}
inline void Envelope::_internal_set_content(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.content_.Set(value, GetArenaForAllocation());
}
inline std::string* Envelope::_internal_mutable_content() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.content_.Mutable(GetArenaForAllocation());
}
inline std::string* Envelope::release_content() {
  // @@protoc_insertion_point(field_release:SessionProtos.Envelope.content)
  if (!_internal_has_content()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.content_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.content_.IsDefault()) {
    _impl_.content_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Envelope::set_allocated_content(std::string* content) {
  if (content != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.content_.SetAllocated(content, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.content_.IsDefault()) {
    _impl_.content_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.Envelope.content)
}

// optional uint64 serverTimestamp = 10;
inline bool Envelope::_internal_has_servertimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Envelope::has_servertimestamp() const {
  return _internal_has_servertimestamp();
}
inline void Envelope::clear_servertimestamp() {
  _impl_.servertimestamp_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint64_t Envelope::_internal_servertimestamp() const {
  return _impl_.servertimestamp_;
}
inline uint64_t Envelope::servertimestamp() const {
  // @@protoc_insertion_point(field_get:SessionProtos.Envelope.serverTimestamp)
  return _internal_servertimestamp();
}
inline void Envelope::_internal_set_servertimestamp(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.servertimestamp_ = value;
}
inline void Envelope::set_servertimestamp(uint64_t value) {
  _internal_set_servertimestamp(value);
  // @@protoc_insertion_point(field_set:SessionProtos.Envelope.serverTimestamp)
}

// optional bytes proSig = 11;
inline bool Envelope::_internal_has_prosig() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Envelope::has_prosig() const {
  return _internal_has_prosig();
}
inline void Envelope::clear_prosig() {
  _impl_.prosig_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& Envelope::prosig() const {
  // @@protoc_insertion_point(field_get:SessionProtos.Envelope.proSig)
  return _internal_prosig();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Envelope::set_prosig(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.prosig_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.Envelope.proSig)
}
inline std::string* Envelope::mutable_prosig() {
  std::string* _s = _internal_mutable_prosig();
  // @@protoc_insertion_point(field_mutable:SessionProtos.Envelope.proSig)
  return _s;
}
inline const std::string& Envelope::_internal_prosig() const {
  return _impl_.prosig_.Get();
}
inline void Envelope::_internal_set_prosig(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.prosig_.Set(value, GetArenaForAllocation());
}
inline std::string* Envelope::_internal_mutable_prosig() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.prosig_.Mutable(GetArenaForAllocation());
}
inline std::string* Envelope::release_prosig() {
  // @@protoc_insertion_point(field_release:SessionProtos.Envelope.proSig)
  if (!_internal_has_prosig()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.prosig_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.prosig_.IsDefault()) {
    _impl_.prosig_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Envelope::set_allocated_prosig(std::string* prosig) {
  if (prosig != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.prosig_.SetAllocated(prosig, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.prosig_.IsDefault()) {
    _impl_.prosig_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.Envelope.proSig)
}

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

// TypingMessage

// required uint64 timestamp = 1;
inline bool TypingMessage::_internal_has_timestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool TypingMessage::has_timestamp() const {
  return _internal_has_timestamp();
}
inline void TypingMessage::clear_timestamp() {
  _impl_.timestamp_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t TypingMessage::_internal_timestamp() const {
  return _impl_.timestamp_;
}
inline uint64_t TypingMessage::timestamp() const {
  // @@protoc_insertion_point(field_get:SessionProtos.TypingMessage.timestamp)
  return _internal_timestamp();
}
inline void TypingMessage::_internal_set_timestamp(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.timestamp_ = value;
}
inline void TypingMessage::set_timestamp(uint64_t value) {
  _internal_set_timestamp(value);
  // @@protoc_insertion_point(field_set:SessionProtos.TypingMessage.timestamp)
}

// required .SessionProtos.TypingMessage.Action action = 2;
inline bool TypingMessage::_internal_has_action() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool TypingMessage::has_action() const {
  return _internal_has_action();
}
inline void TypingMessage::clear_action() {
  _impl_.action_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::SessionProtos::TypingMessage_Action TypingMessage::_internal_action() const {
  return static_cast< ::SessionProtos::TypingMessage_Action >(_impl_.action_);
}
inline ::SessionProtos::TypingMessage_Action TypingMessage::action() const {
  // @@protoc_insertion_point(field_get:SessionProtos.TypingMessage.action)
  return _internal_action();
}
inline void TypingMessage::_internal_set_action(::SessionProtos::TypingMessage_Action value) {
  assert(::SessionProtos::TypingMessage_Action_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.action_ = value;
}
inline void TypingMessage::set_action(::SessionProtos::TypingMessage_Action value) {
  _internal_set_action(value);
  // @@protoc_insertion_point(field_set:SessionProtos.TypingMessage.action)
}

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

// UnsendRequest

// required uint64 timestamp = 1;
inline bool UnsendRequest::_internal_has_timestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool UnsendRequest::has_timestamp() const {
  return _internal_has_timestamp();
}
inline void UnsendRequest::clear_timestamp() {
  _impl_.timestamp_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t UnsendRequest::_internal_timestamp() const {
  return _impl_.timestamp_;
}
inline uint64_t UnsendRequest::timestamp() const {
  // @@protoc_insertion_point(field_get:SessionProtos.UnsendRequest.timestamp)
  return _internal_timestamp();
}
inline void UnsendRequest::_internal_set_timestamp(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.timestamp_ = value;
}
inline void UnsendRequest::set_timestamp(uint64_t value) {
  _internal_set_timestamp(value);
  // @@protoc_insertion_point(field_set:SessionProtos.UnsendRequest.timestamp)
}

// required string author = 2;
inline bool UnsendRequest::_internal_has_author() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool UnsendRequest::has_author() const {
  return _internal_has_author();
}
inline void UnsendRequest::clear_author() {
  _impl_.author_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& UnsendRequest::author() const {
  // @@protoc_insertion_point(field_get:SessionProtos.UnsendRequest.author)
  return _internal_author();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void UnsendRequest::set_author(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.author_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.UnsendRequest.author)
}
inline std::string* UnsendRequest::mutable_author() {
  std::string* _s = _internal_mutable_author();
  // @@protoc_insertion_point(field_mutable:SessionProtos.UnsendRequest.author)
  return _s;
}
inline const std::string& UnsendRequest::_internal_author() const {
  return _impl_.author_.Get();
}
inline void UnsendRequest::_internal_set_author(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.author_.Set(value, GetArenaForAllocation());
}
inline std::string* UnsendRequest::_internal_mutable_author() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.author_.Mutable(GetArenaForAllocation());
}
inline std::string* UnsendRequest::release_author() {
  // @@protoc_insertion_point(field_release:SessionProtos.UnsendRequest.author)
  if (!_internal_has_author()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.author_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.author_.IsDefault()) {
    _impl_.author_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void UnsendRequest::set_allocated_author(std::string* author) {
  if (author != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.author_.SetAllocated(author, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.author_.IsDefault()) {
    _impl_.author_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.UnsendRequest.author)
}

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

// MessageRequestResponse

// required bool isApproved = 1;
inline bool MessageRequestResponse::_internal_has_isapproved() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool MessageRequestResponse::has_isapproved() const {
  return _internal_has_isapproved();
}
inline void MessageRequestResponse::clear_isapproved() {
  _impl_.isapproved_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool MessageRequestResponse::_internal_isapproved() const {
  return _impl_.isapproved_;
}
inline bool MessageRequestResponse::isapproved() const {
  // @@protoc_insertion_point(field_get:SessionProtos.MessageRequestResponse.isApproved)
  return _internal_isapproved();
}
inline void MessageRequestResponse::_internal_set_isapproved(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.isapproved_ = value;
}
inline void MessageRequestResponse::set_isapproved(bool value) {
  _internal_set_isapproved(value);
  // @@protoc_insertion_point(field_set:SessionProtos.MessageRequestResponse.isApproved)
}

// optional bytes profileKey = 2;
inline bool MessageRequestResponse::_internal_has_profilekey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MessageRequestResponse::has_profilekey() const {
  return _internal_has_profilekey();
}
inline void MessageRequestResponse::clear_profilekey() {
  _impl_.profilekey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& MessageRequestResponse::profilekey() const {
  // @@protoc_insertion_point(field_get:SessionProtos.MessageRequestResponse.profileKey)
  return _internal_profilekey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MessageRequestResponse::set_profilekey(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.profilekey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.MessageRequestResponse.profileKey)
}
inline std::string* MessageRequestResponse::mutable_profilekey() {
  std::string* _s = _internal_mutable_profilekey();
  // @@protoc_insertion_point(field_mutable:SessionProtos.MessageRequestResponse.profileKey)
  return _s;
}
inline const std::string& MessageRequestResponse::_internal_profilekey() const {
  return _impl_.profilekey_.Get();
}
inline void MessageRequestResponse::_internal_set_profilekey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.profilekey_.Set(value, GetArenaForAllocation());
}
inline std::string* MessageRequestResponse::_internal_mutable_profilekey() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.profilekey_.Mutable(GetArenaForAllocation());
}
inline std::string* MessageRequestResponse::release_profilekey() {
  // @@protoc_insertion_point(field_release:SessionProtos.MessageRequestResponse.profileKey)
  if (!_internal_has_profilekey()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.profilekey_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.profilekey_.IsDefault()) {
    _impl_.profilekey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void MessageRequestResponse::set_allocated_profilekey(std::string* profilekey) {
  if (profilekey != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.profilekey_.SetAllocated(profilekey, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.profilekey_.IsDefault()) {
    _impl_.profilekey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.MessageRequestResponse.profileKey)
}

// optional .SessionProtos.LokiProfile profile = 3;
inline bool MessageRequestResponse::_internal_has_profile() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.profile_ != nullptr);
  return value;
}
inline bool MessageRequestResponse::has_profile() const {
  return _internal_has_profile();
}
inline void MessageRequestResponse::clear_profile() {
  if (_impl_.profile_ != nullptr) _impl_.profile_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::SessionProtos::LokiProfile& MessageRequestResponse::_internal_profile() const {
  const ::SessionProtos::LokiProfile* p = _impl_.profile_;
  return p != nullptr ? *p : reinterpret_cast<const ::SessionProtos::LokiProfile&>(
      ::SessionProtos::_LokiProfile_default_instance_);
}
inline const ::SessionProtos::LokiProfile& MessageRequestResponse::profile() const {
  // @@protoc_insertion_point(field_get:SessionProtos.MessageRequestResponse.profile)
  return _internal_profile();
}
inline void MessageRequestResponse::unsafe_arena_set_allocated_profile(
    ::SessionProtos::LokiProfile* profile) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.profile_);
  }
  _impl_.profile_ = profile;
  if (profile) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:SessionProtos.MessageRequestResponse.profile)
}
inline ::SessionProtos::LokiProfile* MessageRequestResponse::release_profile() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::SessionProtos::LokiProfile* temp = _impl_.profile_;
  _impl_.profile_ = 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 ::SessionProtos::LokiProfile* MessageRequestResponse::unsafe_arena_release_profile() {
  // @@protoc_insertion_point(field_release:SessionProtos.MessageRequestResponse.profile)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::SessionProtos::LokiProfile* temp = _impl_.profile_;
  _impl_.profile_ = nullptr;
  return temp;
}
inline ::SessionProtos::LokiProfile* MessageRequestResponse::_internal_mutable_profile() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.profile_ == nullptr) {
    auto* p = CreateMaybeMessage<::SessionProtos::LokiProfile>(GetArenaForAllocation());
    _impl_.profile_ = p;
  }
  return _impl_.profile_;
}
inline ::SessionProtos::LokiProfile* MessageRequestResponse::mutable_profile() {
  ::SessionProtos::LokiProfile* _msg = _internal_mutable_profile();
  // @@protoc_insertion_point(field_mutable:SessionProtos.MessageRequestResponse.profile)
  return _msg;
}
inline void MessageRequestResponse::set_allocated_profile(::SessionProtos::LokiProfile* profile) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.profile_;
  }
  if (profile) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(profile);
    if (message_arena != submessage_arena) {
      profile = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, profile, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.profile_ = profile;
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.MessageRequestResponse.profile)
}

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

// Content

// optional .SessionProtos.DataMessage dataMessage = 1;
inline bool Content::_internal_has_datamessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.datamessage_ != nullptr);
  return value;
}
inline bool Content::has_datamessage() const {
  return _internal_has_datamessage();
}
inline void Content::clear_datamessage() {
  if (_impl_.datamessage_ != nullptr) _impl_.datamessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::SessionProtos::DataMessage& Content::_internal_datamessage() const {
  const ::SessionProtos::DataMessage* p = _impl_.datamessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::SessionProtos::DataMessage&>(
      ::SessionProtos::_DataMessage_default_instance_);
}
inline const ::SessionProtos::DataMessage& Content::datamessage() const {
  // @@protoc_insertion_point(field_get:SessionProtos.Content.dataMessage)
  return _internal_datamessage();
}
inline void Content::unsafe_arena_set_allocated_datamessage(
    ::SessionProtos::DataMessage* datamessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.datamessage_);
  }
  _impl_.datamessage_ = datamessage;
  if (datamessage) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:SessionProtos.Content.dataMessage)
}
inline ::SessionProtos::DataMessage* Content::release_datamessage() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::SessionProtos::DataMessage* temp = _impl_.datamessage_;
  _impl_.datamessage_ = 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 ::SessionProtos::DataMessage* Content::unsafe_arena_release_datamessage() {
  // @@protoc_insertion_point(field_release:SessionProtos.Content.dataMessage)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::SessionProtos::DataMessage* temp = _impl_.datamessage_;
  _impl_.datamessage_ = nullptr;
  return temp;
}
inline ::SessionProtos::DataMessage* Content::_internal_mutable_datamessage() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.datamessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::SessionProtos::DataMessage>(GetArenaForAllocation());
    _impl_.datamessage_ = p;
  }
  return _impl_.datamessage_;
}
inline ::SessionProtos::DataMessage* Content::mutable_datamessage() {
  ::SessionProtos::DataMessage* _msg = _internal_mutable_datamessage();
  // @@protoc_insertion_point(field_mutable:SessionProtos.Content.dataMessage)
  return _msg;
}
inline void Content::set_allocated_datamessage(::SessionProtos::DataMessage* datamessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.datamessage_;
  }
  if (datamessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(datamessage);
    if (message_arena != submessage_arena) {
      datamessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, datamessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.datamessage_ = datamessage;
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.Content.dataMessage)
}

// optional .SessionProtos.CallMessage callMessage = 3;
inline bool Content::_internal_has_callmessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.callmessage_ != nullptr);
  return value;
}
inline bool Content::has_callmessage() const {
  return _internal_has_callmessage();
}
inline void Content::clear_callmessage() {
  if (_impl_.callmessage_ != nullptr) _impl_.callmessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::SessionProtos::CallMessage& Content::_internal_callmessage() const {
  const ::SessionProtos::CallMessage* p = _impl_.callmessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::SessionProtos::CallMessage&>(
      ::SessionProtos::_CallMessage_default_instance_);
}
inline const ::SessionProtos::CallMessage& Content::callmessage() const {
  // @@protoc_insertion_point(field_get:SessionProtos.Content.callMessage)
  return _internal_callmessage();
}
inline void Content::unsafe_arena_set_allocated_callmessage(
    ::SessionProtos::CallMessage* callmessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.callmessage_);
  }
  _impl_.callmessage_ = callmessage;
  if (callmessage) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:SessionProtos.Content.callMessage)
}
inline ::SessionProtos::CallMessage* Content::release_callmessage() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::SessionProtos::CallMessage* temp = _impl_.callmessage_;
  _impl_.callmessage_ = 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 ::SessionProtos::CallMessage* Content::unsafe_arena_release_callmessage() {
  // @@protoc_insertion_point(field_release:SessionProtos.Content.callMessage)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::SessionProtos::CallMessage* temp = _impl_.callmessage_;
  _impl_.callmessage_ = nullptr;
  return temp;
}
inline ::SessionProtos::CallMessage* Content::_internal_mutable_callmessage() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.callmessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::SessionProtos::CallMessage>(GetArenaForAllocation());
    _impl_.callmessage_ = p;
  }
  return _impl_.callmessage_;
}
inline ::SessionProtos::CallMessage* Content::mutable_callmessage() {
  ::SessionProtos::CallMessage* _msg = _internal_mutable_callmessage();
  // @@protoc_insertion_point(field_mutable:SessionProtos.Content.callMessage)
  return _msg;
}
inline void Content::set_allocated_callmessage(::SessionProtos::CallMessage* callmessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.callmessage_;
  }
  if (callmessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(callmessage);
    if (message_arena != submessage_arena) {
      callmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, callmessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.callmessage_ = callmessage;
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.Content.callMessage)
}

// optional .SessionProtos.ReceiptMessage receiptMessage = 5;
inline bool Content::_internal_has_receiptmessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.receiptmessage_ != nullptr);
  return value;
}
inline bool Content::has_receiptmessage() const {
  return _internal_has_receiptmessage();
}
inline void Content::clear_receiptmessage() {
  if (_impl_.receiptmessage_ != nullptr) _impl_.receiptmessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::SessionProtos::ReceiptMessage& Content::_internal_receiptmessage() const {
  const ::SessionProtos::ReceiptMessage* p = _impl_.receiptmessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::SessionProtos::ReceiptMessage&>(
      ::SessionProtos::_ReceiptMessage_default_instance_);
}
inline const ::SessionProtos::ReceiptMessage& Content::receiptmessage() const {
  // @@protoc_insertion_point(field_get:SessionProtos.Content.receiptMessage)
  return _internal_receiptmessage();
}
inline void Content::unsafe_arena_set_allocated_receiptmessage(
    ::SessionProtos::ReceiptMessage* receiptmessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.receiptmessage_);
  }
  _impl_.receiptmessage_ = receiptmessage;
  if (receiptmessage) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:SessionProtos.Content.receiptMessage)
}
inline ::SessionProtos::ReceiptMessage* Content::release_receiptmessage() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::SessionProtos::ReceiptMessage* temp = _impl_.receiptmessage_;
  _impl_.receiptmessage_ = 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 ::SessionProtos::ReceiptMessage* Content::unsafe_arena_release_receiptmessage() {
  // @@protoc_insertion_point(field_release:SessionProtos.Content.receiptMessage)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::SessionProtos::ReceiptMessage* temp = _impl_.receiptmessage_;
  _impl_.receiptmessage_ = nullptr;
  return temp;
}
inline ::SessionProtos::ReceiptMessage* Content::_internal_mutable_receiptmessage() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.receiptmessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::SessionProtos::ReceiptMessage>(GetArenaForAllocation());
    _impl_.receiptmessage_ = p;
  }
  return _impl_.receiptmessage_;
}
inline ::SessionProtos::ReceiptMessage* Content::mutable_receiptmessage() {
  ::SessionProtos::ReceiptMessage* _msg = _internal_mutable_receiptmessage();
  // @@protoc_insertion_point(field_mutable:SessionProtos.Content.receiptMessage)
  return _msg;
}
inline void Content::set_allocated_receiptmessage(::SessionProtos::ReceiptMessage* receiptmessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.receiptmessage_;
  }
  if (receiptmessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(receiptmessage);
    if (message_arena != submessage_arena) {
      receiptmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, receiptmessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.receiptmessage_ = receiptmessage;
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.Content.receiptMessage)
}

// optional .SessionProtos.TypingMessage typingMessage = 6;
inline bool Content::_internal_has_typingmessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.typingmessage_ != nullptr);
  return value;
}
inline bool Content::has_typingmessage() const {
  return _internal_has_typingmessage();
}
inline void Content::clear_typingmessage() {
  if (_impl_.typingmessage_ != nullptr) _impl_.typingmessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const ::SessionProtos::TypingMessage& Content::_internal_typingmessage() const {
  const ::SessionProtos::TypingMessage* p = _impl_.typingmessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::SessionProtos::TypingMessage&>(
      ::SessionProtos::_TypingMessage_default_instance_);
}
inline const ::SessionProtos::TypingMessage& Content::typingmessage() const {
  // @@protoc_insertion_point(field_get:SessionProtos.Content.typingMessage)
  return _internal_typingmessage();
}
inline void Content::unsafe_arena_set_allocated_typingmessage(
    ::SessionProtos::TypingMessage* typingmessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.typingmessage_);
  }
  _impl_.typingmessage_ = typingmessage;
  if (typingmessage) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:SessionProtos.Content.typingMessage)
}
inline ::SessionProtos::TypingMessage* Content::release_typingmessage() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::SessionProtos::TypingMessage* temp = _impl_.typingmessage_;
  _impl_.typingmessage_ = 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 ::SessionProtos::TypingMessage* Content::unsafe_arena_release_typingmessage() {
  // @@protoc_insertion_point(field_release:SessionProtos.Content.typingMessage)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::SessionProtos::TypingMessage* temp = _impl_.typingmessage_;
  _impl_.typingmessage_ = nullptr;
  return temp;
}
inline ::SessionProtos::TypingMessage* Content::_internal_mutable_typingmessage() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.typingmessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::SessionProtos::TypingMessage>(GetArenaForAllocation());
    _impl_.typingmessage_ = p;
  }
  return _impl_.typingmessage_;
}
inline ::SessionProtos::TypingMessage* Content::mutable_typingmessage() {
  ::SessionProtos::TypingMessage* _msg = _internal_mutable_typingmessage();
  // @@protoc_insertion_point(field_mutable:SessionProtos.Content.typingMessage)
  return _msg;
}
inline void Content::set_allocated_typingmessage(::SessionProtos::TypingMessage* typingmessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.typingmessage_;
  }
  if (typingmessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(typingmessage);
    if (message_arena != submessage_arena) {
      typingmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, typingmessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.typingmessage_ = typingmessage;
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.Content.typingMessage)
}

// optional .SessionProtos.DataExtractionNotification dataExtractionNotification = 8;
inline bool Content::_internal_has_dataextractionnotification() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.dataextractionnotification_ != nullptr);
  return value;
}
inline bool Content::has_dataextractionnotification() const {
  return _internal_has_dataextractionnotification();
}
inline void Content::clear_dataextractionnotification() {
  if (_impl_.dataextractionnotification_ != nullptr) _impl_.dataextractionnotification_->Clear();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const ::SessionProtos::DataExtractionNotification& Content::_internal_dataextractionnotification() const {
  const ::SessionProtos::DataExtractionNotification* p = _impl_.dataextractionnotification_;
  return p != nullptr ? *p : reinterpret_cast<const ::SessionProtos::DataExtractionNotification&>(
      ::SessionProtos::_DataExtractionNotification_default_instance_);
}
inline const ::SessionProtos::DataExtractionNotification& Content::dataextractionnotification() const {
  // @@protoc_insertion_point(field_get:SessionProtos.Content.dataExtractionNotification)
  return _internal_dataextractionnotification();
}
inline void Content::unsafe_arena_set_allocated_dataextractionnotification(
    ::SessionProtos::DataExtractionNotification* dataextractionnotification) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.dataextractionnotification_);
  }
  _impl_.dataextractionnotification_ = dataextractionnotification;
  if (dataextractionnotification) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:SessionProtos.Content.dataExtractionNotification)
}
inline ::SessionProtos::DataExtractionNotification* Content::release_dataextractionnotification() {
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::SessionProtos::DataExtractionNotification* temp = _impl_.dataextractionnotification_;
  _impl_.dataextractionnotification_ = 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 ::SessionProtos::DataExtractionNotification* Content::unsafe_arena_release_dataextractionnotification() {
  // @@protoc_insertion_point(field_release:SessionProtos.Content.dataExtractionNotification)
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::SessionProtos::DataExtractionNotification* temp = _impl_.dataextractionnotification_;
  _impl_.dataextractionnotification_ = nullptr;
  return temp;
}
inline ::SessionProtos::DataExtractionNotification* Content::_internal_mutable_dataextractionnotification() {
  _impl_._has_bits_[0] |= 0x00000020u;
  if (_impl_.dataextractionnotification_ == nullptr) {
    auto* p = CreateMaybeMessage<::SessionProtos::DataExtractionNotification>(GetArenaForAllocation());
    _impl_.dataextractionnotification_ = p;
  }
  return _impl_.dataextractionnotification_;
}
inline ::SessionProtos::DataExtractionNotification* Content::mutable_dataextractionnotification() {
  ::SessionProtos::DataExtractionNotification* _msg = _internal_mutable_dataextractionnotification();
  // @@protoc_insertion_point(field_mutable:SessionProtos.Content.dataExtractionNotification)
  return _msg;
}
inline void Content::set_allocated_dataextractionnotification(::SessionProtos::DataExtractionNotification* dataextractionnotification) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.dataextractionnotification_;
  }
  if (dataextractionnotification) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(dataextractionnotification);
    if (message_arena != submessage_arena) {
      dataextractionnotification = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, dataextractionnotification, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.dataextractionnotification_ = dataextractionnotification;
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.Content.dataExtractionNotification)
}

// optional .SessionProtos.UnsendRequest unsendRequest = 9;
inline bool Content::_internal_has_unsendrequest() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.unsendrequest_ != nullptr);
  return value;
}
inline bool Content::has_unsendrequest() const {
  return _internal_has_unsendrequest();
}
inline void Content::clear_unsendrequest() {
  if (_impl_.unsendrequest_ != nullptr) _impl_.unsendrequest_->Clear();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const ::SessionProtos::UnsendRequest& Content::_internal_unsendrequest() const {
  const ::SessionProtos::UnsendRequest* p = _impl_.unsendrequest_;
  return p != nullptr ? *p : reinterpret_cast<const ::SessionProtos::UnsendRequest&>(
      ::SessionProtos::_UnsendRequest_default_instance_);
}
inline const ::SessionProtos::UnsendRequest& Content::unsendrequest() const {
  // @@protoc_insertion_point(field_get:SessionProtos.Content.unsendRequest)
  return _internal_unsendrequest();
}
inline void Content::unsafe_arena_set_allocated_unsendrequest(
    ::SessionProtos::UnsendRequest* unsendrequest) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.unsendrequest_);
  }
  _impl_.unsendrequest_ = unsendrequest;
  if (unsendrequest) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:SessionProtos.Content.unsendRequest)
}
inline ::SessionProtos::UnsendRequest* Content::release_unsendrequest() {
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::SessionProtos::UnsendRequest* temp = _impl_.unsendrequest_;
  _impl_.unsendrequest_ = 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 ::SessionProtos::UnsendRequest* Content::unsafe_arena_release_unsendrequest() {
  // @@protoc_insertion_point(field_release:SessionProtos.Content.unsendRequest)
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::SessionProtos::UnsendRequest* temp = _impl_.unsendrequest_;
  _impl_.unsendrequest_ = nullptr;
  return temp;
}
inline ::SessionProtos::UnsendRequest* Content::_internal_mutable_unsendrequest() {
  _impl_._has_bits_[0] |= 0x00000040u;
  if (_impl_.unsendrequest_ == nullptr) {
    auto* p = CreateMaybeMessage<::SessionProtos::UnsendRequest>(GetArenaForAllocation());
    _impl_.unsendrequest_ = p;
  }
  return _impl_.unsendrequest_;
}
inline ::SessionProtos::UnsendRequest* Content::mutable_unsendrequest() {
  ::SessionProtos::UnsendRequest* _msg = _internal_mutable_unsendrequest();
  // @@protoc_insertion_point(field_mutable:SessionProtos.Content.unsendRequest)
  return _msg;
}
inline void Content::set_allocated_unsendrequest(::SessionProtos::UnsendRequest* unsendrequest) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.unsendrequest_;
  }
  if (unsendrequest) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(unsendrequest);
    if (message_arena != submessage_arena) {
      unsendrequest = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, unsendrequest, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.unsendrequest_ = unsendrequest;
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.Content.unsendRequest)
}

// optional .SessionProtos.MessageRequestResponse messageRequestResponse = 10;
inline bool Content::_internal_has_messagerequestresponse() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.messagerequestresponse_ != nullptr);
  return value;
}
inline bool Content::has_messagerequestresponse() const {
  return _internal_has_messagerequestresponse();
}
inline void Content::clear_messagerequestresponse() {
  if (_impl_.messagerequestresponse_ != nullptr) _impl_.messagerequestresponse_->Clear();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const ::SessionProtos::MessageRequestResponse& Content::_internal_messagerequestresponse() const {
  const ::SessionProtos::MessageRequestResponse* p = _impl_.messagerequestresponse_;
  return p != nullptr ? *p : reinterpret_cast<const ::SessionProtos::MessageRequestResponse&>(
      ::SessionProtos::_MessageRequestResponse_default_instance_);
}
inline const ::SessionProtos::MessageRequestResponse& Content::messagerequestresponse() const {
  // @@protoc_insertion_point(field_get:SessionProtos.Content.messageRequestResponse)
  return _internal_messagerequestresponse();
}
inline void Content::unsafe_arena_set_allocated_messagerequestresponse(
    ::SessionProtos::MessageRequestResponse* messagerequestresponse) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.messagerequestresponse_);
  }
  _impl_.messagerequestresponse_ = messagerequestresponse;
  if (messagerequestresponse) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:SessionProtos.Content.messageRequestResponse)
}
inline ::SessionProtos::MessageRequestResponse* Content::release_messagerequestresponse() {
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::SessionProtos::MessageRequestResponse* temp = _impl_.messagerequestresponse_;
  _impl_.messagerequestresponse_ = 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 ::SessionProtos::MessageRequestResponse* Content::unsafe_arena_release_messagerequestresponse() {
  // @@protoc_insertion_point(field_release:SessionProtos.Content.messageRequestResponse)
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::SessionProtos::MessageRequestResponse* temp = _impl_.messagerequestresponse_;
  _impl_.messagerequestresponse_ = nullptr;
  return temp;
}
inline ::SessionProtos::MessageRequestResponse* Content::_internal_mutable_messagerequestresponse() {
  _impl_._has_bits_[0] |= 0x00000080u;
  if (_impl_.messagerequestresponse_ == nullptr) {
    auto* p = CreateMaybeMessage<::SessionProtos::MessageRequestResponse>(GetArenaForAllocation());
    _impl_.messagerequestresponse_ = p;
  }
  return _impl_.messagerequestresponse_;
}
inline ::SessionProtos::MessageRequestResponse* Content::mutable_messagerequestresponse() {
  ::SessionProtos::MessageRequestResponse* _msg = _internal_mutable_messagerequestresponse();
  // @@protoc_insertion_point(field_mutable:SessionProtos.Content.messageRequestResponse)
  return _msg;
}
inline void Content::set_allocated_messagerequestresponse(::SessionProtos::MessageRequestResponse* messagerequestresponse) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.messagerequestresponse_;
  }
  if (messagerequestresponse) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(messagerequestresponse);
    if (message_arena != submessage_arena) {
      messagerequestresponse = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, messagerequestresponse, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.messagerequestresponse_ = messagerequestresponse;
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.Content.messageRequestResponse)
}

// optional .SessionProtos.SharedConfigMessage sharedConfigMessage = 11;
inline bool Content::_internal_has_sharedconfigmessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.sharedconfigmessage_ != nullptr);
  return value;
}
inline bool Content::has_sharedconfigmessage() const {
  return _internal_has_sharedconfigmessage();
}
inline void Content::clear_sharedconfigmessage() {
  if (_impl_.sharedconfigmessage_ != nullptr) _impl_.sharedconfigmessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline const ::SessionProtos::SharedConfigMessage& Content::_internal_sharedconfigmessage() const {
  const ::SessionProtos::SharedConfigMessage* p = _impl_.sharedconfigmessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::SessionProtos::SharedConfigMessage&>(
      ::SessionProtos::_SharedConfigMessage_default_instance_);
}
inline const ::SessionProtos::SharedConfigMessage& Content::sharedconfigmessage() const {
  // @@protoc_insertion_point(field_get:SessionProtos.Content.sharedConfigMessage)
  return _internal_sharedconfigmessage();
}
inline void Content::unsafe_arena_set_allocated_sharedconfigmessage(
    ::SessionProtos::SharedConfigMessage* sharedconfigmessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.sharedconfigmessage_);
  }
  _impl_.sharedconfigmessage_ = sharedconfigmessage;
  if (sharedconfigmessage) {
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:SessionProtos.Content.sharedConfigMessage)
}
inline ::SessionProtos::SharedConfigMessage* Content::release_sharedconfigmessage() {
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::SessionProtos::SharedConfigMessage* temp = _impl_.sharedconfigmessage_;
  _impl_.sharedconfigmessage_ = 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 ::SessionProtos::SharedConfigMessage* Content::unsafe_arena_release_sharedconfigmessage() {
  // @@protoc_insertion_point(field_release:SessionProtos.Content.sharedConfigMessage)
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::SessionProtos::SharedConfigMessage* temp = _impl_.sharedconfigmessage_;
  _impl_.sharedconfigmessage_ = nullptr;
  return temp;
}
inline ::SessionProtos::SharedConfigMessage* Content::_internal_mutable_sharedconfigmessage() {
  _impl_._has_bits_[0] |= 0x00000100u;
  if (_impl_.sharedconfigmessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::SessionProtos::SharedConfigMessage>(GetArenaForAllocation());
    _impl_.sharedconfigmessage_ = p;
  }
  return _impl_.sharedconfigmessage_;
}
inline ::SessionProtos::SharedConfigMessage* Content::mutable_sharedconfigmessage() {
  ::SessionProtos::SharedConfigMessage* _msg = _internal_mutable_sharedconfigmessage();
  // @@protoc_insertion_point(field_mutable:SessionProtos.Content.sharedConfigMessage)
  return _msg;
}
inline void Content::set_allocated_sharedconfigmessage(::SessionProtos::SharedConfigMessage* sharedconfigmessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.sharedconfigmessage_;
  }
  if (sharedconfigmessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(sharedconfigmessage);
    if (message_arena != submessage_arena) {
      sharedconfigmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, sharedconfigmessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  _impl_.sharedconfigmessage_ = sharedconfigmessage;
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.Content.sharedConfigMessage)
}

// optional .SessionProtos.Content.ExpirationType expirationType = 12;
inline bool Content::_internal_has_expirationtype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool Content::has_expirationtype() const {
  return _internal_has_expirationtype();
}
inline void Content::clear_expirationtype() {
  _impl_.expirationtype_ = 0;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline ::SessionProtos::Content_ExpirationType Content::_internal_expirationtype() const {
  return static_cast< ::SessionProtos::Content_ExpirationType >(_impl_.expirationtype_);
}
inline ::SessionProtos::Content_ExpirationType Content::expirationtype() const {
  // @@protoc_insertion_point(field_get:SessionProtos.Content.expirationType)
  return _internal_expirationtype();
}
inline void Content::_internal_set_expirationtype(::SessionProtos::Content_ExpirationType value) {
  assert(::SessionProtos::Content_ExpirationType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.expirationtype_ = value;
}
inline void Content::set_expirationtype(::SessionProtos::Content_ExpirationType value) {
  _internal_set_expirationtype(value);
  // @@protoc_insertion_point(field_set:SessionProtos.Content.expirationType)
}

// optional uint32 expirationTimer = 13;
inline bool Content::_internal_has_expirationtimer() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool Content::has_expirationtimer() const {
  return _internal_has_expirationtimer();
}
inline void Content::clear_expirationtimer() {
  _impl_.expirationtimer_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline uint32_t Content::_internal_expirationtimer() const {
  return _impl_.expirationtimer_;
}
inline uint32_t Content::expirationtimer() const {
  // @@protoc_insertion_point(field_get:SessionProtos.Content.expirationTimer)
  return _internal_expirationtimer();
}
inline void Content::_internal_set_expirationtimer(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.expirationtimer_ = value;
}
inline void Content::set_expirationtimer(uint32_t value) {
  _internal_set_expirationtimer(value);
  // @@protoc_insertion_point(field_set:SessionProtos.Content.expirationTimer)
}

// optional uint64 sigTimestamp = 15;
inline bool Content::_internal_has_sigtimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool Content::has_sigtimestamp() const {
  return _internal_has_sigtimestamp();
}
inline void Content::clear_sigtimestamp() {
  _impl_.sigtimestamp_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline uint64_t Content::_internal_sigtimestamp() const {
  return _impl_.sigtimestamp_;
}
inline uint64_t Content::sigtimestamp() const {
  // @@protoc_insertion_point(field_get:SessionProtos.Content.sigTimestamp)
  return _internal_sigtimestamp();
}
inline void Content::_internal_set_sigtimestamp(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.sigtimestamp_ = value;
}
inline void Content::set_sigtimestamp(uint64_t value) {
  _internal_set_sigtimestamp(value);
  // @@protoc_insertion_point(field_set:SessionProtos.Content.sigTimestamp)
}

// optional .SessionProtos.ProMessage proMessage = 16;
inline bool Content::_internal_has_promessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.promessage_ != nullptr);
  return value;
}
inline bool Content::has_promessage() const {
  return _internal_has_promessage();
}
inline void Content::clear_promessage() {
  if (_impl_.promessage_ != nullptr) _impl_.promessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline const ::SessionProtos::ProMessage& Content::_internal_promessage() const {
  const ::SessionProtos::ProMessage* p = _impl_.promessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::SessionProtos::ProMessage&>(
      ::SessionProtos::_ProMessage_default_instance_);
}
inline const ::SessionProtos::ProMessage& Content::promessage() const {
  // @@protoc_insertion_point(field_get:SessionProtos.Content.proMessage)
  return _internal_promessage();
}
inline void Content::unsafe_arena_set_allocated_promessage(
    ::SessionProtos::ProMessage* promessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.promessage_);
  }
  _impl_.promessage_ = promessage;
  if (promessage) {
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:SessionProtos.Content.proMessage)
}
inline ::SessionProtos::ProMessage* Content::release_promessage() {
  _impl_._has_bits_[0] &= ~0x00000200u;
  ::SessionProtos::ProMessage* temp = _impl_.promessage_;
  _impl_.promessage_ = 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 ::SessionProtos::ProMessage* Content::unsafe_arena_release_promessage() {
  // @@protoc_insertion_point(field_release:SessionProtos.Content.proMessage)
  _impl_._has_bits_[0] &= ~0x00000200u;
  ::SessionProtos::ProMessage* temp = _impl_.promessage_;
  _impl_.promessage_ = nullptr;
  return temp;
}
inline ::SessionProtos::ProMessage* Content::_internal_mutable_promessage() {
  _impl_._has_bits_[0] |= 0x00000200u;
  if (_impl_.promessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::SessionProtos::ProMessage>(GetArenaForAllocation());
    _impl_.promessage_ = p;
  }
  return _impl_.promessage_;
}
inline ::SessionProtos::ProMessage* Content::mutable_promessage() {
  ::SessionProtos::ProMessage* _msg = _internal_mutable_promessage();
  // @@protoc_insertion_point(field_mutable:SessionProtos.Content.proMessage)
  return _msg;
}
inline void Content::set_allocated_promessage(::SessionProtos::ProMessage* promessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.promessage_;
  }
  if (promessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(promessage);
    if (message_arena != submessage_arena) {
      promessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, promessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  _impl_.promessage_ = promessage;
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.Content.proMessage)
}

// optional bytes proSigForCommunityMessageOnly = 17;
inline bool Content::_internal_has_prosigforcommunitymessageonly() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Content::has_prosigforcommunitymessageonly() const {
  return _internal_has_prosigforcommunitymessageonly();
}
inline void Content::clear_prosigforcommunitymessageonly() {
  _impl_.prosigforcommunitymessageonly_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Content::prosigforcommunitymessageonly() const {
  // @@protoc_insertion_point(field_get:SessionProtos.Content.proSigForCommunityMessageOnly)
  return _internal_prosigforcommunitymessageonly();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Content::set_prosigforcommunitymessageonly(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.prosigforcommunitymessageonly_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.Content.proSigForCommunityMessageOnly)
}
inline std::string* Content::mutable_prosigforcommunitymessageonly() {
  std::string* _s = _internal_mutable_prosigforcommunitymessageonly();
  // @@protoc_insertion_point(field_mutable:SessionProtos.Content.proSigForCommunityMessageOnly)
  return _s;
}
inline const std::string& Content::_internal_prosigforcommunitymessageonly() const {
  return _impl_.prosigforcommunitymessageonly_.Get();
}
inline void Content::_internal_set_prosigforcommunitymessageonly(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.prosigforcommunitymessageonly_.Set(value, GetArenaForAllocation());
}
inline std::string* Content::_internal_mutable_prosigforcommunitymessageonly() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.prosigforcommunitymessageonly_.Mutable(GetArenaForAllocation());
}
inline std::string* Content::release_prosigforcommunitymessageonly() {
  // @@protoc_insertion_point(field_release:SessionProtos.Content.proSigForCommunityMessageOnly)
  if (!_internal_has_prosigforcommunitymessageonly()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.prosigforcommunitymessageonly_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.prosigforcommunitymessageonly_.IsDefault()) {
    _impl_.prosigforcommunitymessageonly_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Content::set_allocated_prosigforcommunitymessageonly(std::string* prosigforcommunitymessageonly) {
  if (prosigforcommunitymessageonly != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.prosigforcommunitymessageonly_.SetAllocated(prosigforcommunitymessageonly, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.prosigforcommunitymessageonly_.IsDefault()) {
    _impl_.prosigforcommunitymessageonly_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.Content.proSigForCommunityMessageOnly)
}

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

// CallMessage

// required .SessionProtos.CallMessage.Type type = 1;
inline bool CallMessage::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CallMessage::has_type() const {
  return _internal_has_type();
}
inline void CallMessage::clear_type() {
  _impl_.type_ = 6;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::SessionProtos::CallMessage_Type CallMessage::_internal_type() const {
  return static_cast< ::SessionProtos::CallMessage_Type >(_impl_.type_);
}
inline ::SessionProtos::CallMessage_Type CallMessage::type() const {
  // @@protoc_insertion_point(field_get:SessionProtos.CallMessage.type)
  return _internal_type();
}
inline void CallMessage::_internal_set_type(::SessionProtos::CallMessage_Type value) {
  assert(::SessionProtos::CallMessage_Type_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.type_ = value;
}
inline void CallMessage::set_type(::SessionProtos::CallMessage_Type value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:SessionProtos.CallMessage.type)
}

// repeated string sdps = 2;
inline int CallMessage::_internal_sdps_size() const {
  return _impl_.sdps_.size();
}
inline int CallMessage::sdps_size() const {
  return _internal_sdps_size();
}
inline void CallMessage::clear_sdps() {
  _impl_.sdps_.Clear();
}
inline std::string* CallMessage::add_sdps() {
  std::string* _s = _internal_add_sdps();
  // @@protoc_insertion_point(field_add_mutable:SessionProtos.CallMessage.sdps)
  return _s;
}
inline const std::string& CallMessage::_internal_sdps(int index) const {
  return _impl_.sdps_.Get(index);
}
inline const std::string& CallMessage::sdps(int index) const {
  // @@protoc_insertion_point(field_get:SessionProtos.CallMessage.sdps)
  return _internal_sdps(index);
}
inline std::string* CallMessage::mutable_sdps(int index) {
  // @@protoc_insertion_point(field_mutable:SessionProtos.CallMessage.sdps)
  return _impl_.sdps_.Mutable(index);
}
inline void CallMessage::set_sdps(int index, const std::string& value) {
  _impl_.sdps_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:SessionProtos.CallMessage.sdps)
}
inline void CallMessage::set_sdps(int index, std::string&& value) {
  _impl_.sdps_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:SessionProtos.CallMessage.sdps)
}
inline void CallMessage::set_sdps(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.sdps_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:SessionProtos.CallMessage.sdps)
}
inline void CallMessage::set_sdps(int index, const char* value, size_t size) {
  _impl_.sdps_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:SessionProtos.CallMessage.sdps)
}
inline std::string* CallMessage::_internal_add_sdps() {
  return _impl_.sdps_.Add();
}
inline void CallMessage::add_sdps(const std::string& value) {
  _impl_.sdps_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:SessionProtos.CallMessage.sdps)
}
inline void CallMessage::add_sdps(std::string&& value) {
  _impl_.sdps_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:SessionProtos.CallMessage.sdps)
}
inline void CallMessage::add_sdps(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.sdps_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:SessionProtos.CallMessage.sdps)
}
inline void CallMessage::add_sdps(const char* value, size_t size) {
  _impl_.sdps_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:SessionProtos.CallMessage.sdps)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
CallMessage::sdps() const {
  // @@protoc_insertion_point(field_list:SessionProtos.CallMessage.sdps)
  return _impl_.sdps_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
CallMessage::mutable_sdps() {
  // @@protoc_insertion_point(field_mutable_list:SessionProtos.CallMessage.sdps)
  return &_impl_.sdps_;
}

// repeated uint32 sdpMLineIndexes = 3;
inline int CallMessage::_internal_sdpmlineindexes_size() const {
  return _impl_.sdpmlineindexes_.size();
}
inline int CallMessage::sdpmlineindexes_size() const {
  return _internal_sdpmlineindexes_size();
}
inline void CallMessage::clear_sdpmlineindexes() {
  _impl_.sdpmlineindexes_.Clear();
}
inline uint32_t CallMessage::_internal_sdpmlineindexes(int index) const {
  return _impl_.sdpmlineindexes_.Get(index);
}
inline uint32_t CallMessage::sdpmlineindexes(int index) const {
  // @@protoc_insertion_point(field_get:SessionProtos.CallMessage.sdpMLineIndexes)
  return _internal_sdpmlineindexes(index);
}
inline void CallMessage::set_sdpmlineindexes(int index, uint32_t value) {
  _impl_.sdpmlineindexes_.Set(index, value);
  // @@protoc_insertion_point(field_set:SessionProtos.CallMessage.sdpMLineIndexes)
}
inline void CallMessage::_internal_add_sdpmlineindexes(uint32_t value) {
  _impl_.sdpmlineindexes_.Add(value);
}
inline void CallMessage::add_sdpmlineindexes(uint32_t value) {
  _internal_add_sdpmlineindexes(value);
  // @@protoc_insertion_point(field_add:SessionProtos.CallMessage.sdpMLineIndexes)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CallMessage::_internal_sdpmlineindexes() const {
  return _impl_.sdpmlineindexes_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CallMessage::sdpmlineindexes() const {
  // @@protoc_insertion_point(field_list:SessionProtos.CallMessage.sdpMLineIndexes)
  return _internal_sdpmlineindexes();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CallMessage::_internal_mutable_sdpmlineindexes() {
  return &_impl_.sdpmlineindexes_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CallMessage::mutable_sdpmlineindexes() {
  // @@protoc_insertion_point(field_mutable_list:SessionProtos.CallMessage.sdpMLineIndexes)
  return _internal_mutable_sdpmlineindexes();
}

// repeated string sdpMids = 4;
inline int CallMessage::_internal_sdpmids_size() const {
  return _impl_.sdpmids_.size();
}
inline int CallMessage::sdpmids_size() const {
  return _internal_sdpmids_size();
}
inline void CallMessage::clear_sdpmids() {
  _impl_.sdpmids_.Clear();
}
inline std::string* CallMessage::add_sdpmids() {
  std::string* _s = _internal_add_sdpmids();
  // @@protoc_insertion_point(field_add_mutable:SessionProtos.CallMessage.sdpMids)
  return _s;
}
inline const std::string& CallMessage::_internal_sdpmids(int index) const {
  return _impl_.sdpmids_.Get(index);
}
inline const std::string& CallMessage::sdpmids(int index) const {
  // @@protoc_insertion_point(field_get:SessionProtos.CallMessage.sdpMids)
  return _internal_sdpmids(index);
}
inline std::string* CallMessage::mutable_sdpmids(int index) {
  // @@protoc_insertion_point(field_mutable:SessionProtos.CallMessage.sdpMids)
  return _impl_.sdpmids_.Mutable(index);
}
inline void CallMessage::set_sdpmids(int index, const std::string& value) {
  _impl_.sdpmids_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:SessionProtos.CallMessage.sdpMids)
}
inline void CallMessage::set_sdpmids(int index, std::string&& value) {
  _impl_.sdpmids_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:SessionProtos.CallMessage.sdpMids)
}
inline void CallMessage::set_sdpmids(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.sdpmids_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:SessionProtos.CallMessage.sdpMids)
}
inline void CallMessage::set_sdpmids(int index, const char* value, size_t size) {
  _impl_.sdpmids_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:SessionProtos.CallMessage.sdpMids)
}
inline std::string* CallMessage::_internal_add_sdpmids() {
  return _impl_.sdpmids_.Add();
}
inline void CallMessage::add_sdpmids(const std::string& value) {
  _impl_.sdpmids_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:SessionProtos.CallMessage.sdpMids)
}
inline void CallMessage::add_sdpmids(std::string&& value) {
  _impl_.sdpmids_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:SessionProtos.CallMessage.sdpMids)
}
inline void CallMessage::add_sdpmids(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.sdpmids_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:SessionProtos.CallMessage.sdpMids)
}
inline void CallMessage::add_sdpmids(const char* value, size_t size) {
  _impl_.sdpmids_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:SessionProtos.CallMessage.sdpMids)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
CallMessage::sdpmids() const {
  // @@protoc_insertion_point(field_list:SessionProtos.CallMessage.sdpMids)
  return _impl_.sdpmids_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
CallMessage::mutable_sdpmids() {
  // @@protoc_insertion_point(field_mutable_list:SessionProtos.CallMessage.sdpMids)
  return &_impl_.sdpmids_;
}

// required string uuid = 5;
inline bool CallMessage::_internal_has_uuid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CallMessage::has_uuid() const {
  return _internal_has_uuid();
}
inline void CallMessage::clear_uuid() {
  _impl_.uuid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CallMessage::uuid() const {
  // @@protoc_insertion_point(field_get:SessionProtos.CallMessage.uuid)
  return _internal_uuid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CallMessage::set_uuid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.uuid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.CallMessage.uuid)
}
inline std::string* CallMessage::mutable_uuid() {
  std::string* _s = _internal_mutable_uuid();
  // @@protoc_insertion_point(field_mutable:SessionProtos.CallMessage.uuid)
  return _s;
}
inline const std::string& CallMessage::_internal_uuid() const {
  return _impl_.uuid_.Get();
}
inline void CallMessage::_internal_set_uuid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.uuid_.Set(value, GetArenaForAllocation());
}
inline std::string* CallMessage::_internal_mutable_uuid() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.uuid_.Mutable(GetArenaForAllocation());
}
inline std::string* CallMessage::release_uuid() {
  // @@protoc_insertion_point(field_release:SessionProtos.CallMessage.uuid)
  if (!_internal_has_uuid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.uuid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.uuid_.IsDefault()) {
    _impl_.uuid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CallMessage::set_allocated_uuid(std::string* uuid) {
  if (uuid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.uuid_.SetAllocated(uuid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.uuid_.IsDefault()) {
    _impl_.uuid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.CallMessage.uuid)
}

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

// KeyPair

// required bytes publicKey = 1;
inline bool KeyPair::_internal_has_publickey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool KeyPair::has_publickey() const {
  return _internal_has_publickey();
}
inline void KeyPair::clear_publickey() {
  _impl_.publickey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& KeyPair::publickey() const {
  // @@protoc_insertion_point(field_get:SessionProtos.KeyPair.publicKey)
  return _internal_publickey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void KeyPair::set_publickey(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.publickey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.KeyPair.publicKey)
}
inline std::string* KeyPair::mutable_publickey() {
  std::string* _s = _internal_mutable_publickey();
  // @@protoc_insertion_point(field_mutable:SessionProtos.KeyPair.publicKey)
  return _s;
}
inline const std::string& KeyPair::_internal_publickey() const {
  return _impl_.publickey_.Get();
}
inline void KeyPair::_internal_set_publickey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.publickey_.Set(value, GetArenaForAllocation());
}
inline std::string* KeyPair::_internal_mutable_publickey() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.publickey_.Mutable(GetArenaForAllocation());
}
inline std::string* KeyPair::release_publickey() {
  // @@protoc_insertion_point(field_release:SessionProtos.KeyPair.publicKey)
  if (!_internal_has_publickey()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.publickey_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.publickey_.IsDefault()) {
    _impl_.publickey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void KeyPair::set_allocated_publickey(std::string* publickey) {
  if (publickey != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.publickey_.SetAllocated(publickey, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.publickey_.IsDefault()) {
    _impl_.publickey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.KeyPair.publicKey)
}

// required bytes privateKey = 2;
inline bool KeyPair::_internal_has_privatekey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool KeyPair::has_privatekey() const {
  return _internal_has_privatekey();
}
inline void KeyPair::clear_privatekey() {
  _impl_.privatekey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& KeyPair::privatekey() const {
  // @@protoc_insertion_point(field_get:SessionProtos.KeyPair.privateKey)
  return _internal_privatekey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void KeyPair::set_privatekey(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.privatekey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.KeyPair.privateKey)
}
inline std::string* KeyPair::mutable_privatekey() {
  std::string* _s = _internal_mutable_privatekey();
  // @@protoc_insertion_point(field_mutable:SessionProtos.KeyPair.privateKey)
  return _s;
}
inline const std::string& KeyPair::_internal_privatekey() const {
  return _impl_.privatekey_.Get();
}
inline void KeyPair::_internal_set_privatekey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.privatekey_.Set(value, GetArenaForAllocation());
}
inline std::string* KeyPair::_internal_mutable_privatekey() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.privatekey_.Mutable(GetArenaForAllocation());
}
inline std::string* KeyPair::release_privatekey() {
  // @@protoc_insertion_point(field_release:SessionProtos.KeyPair.privateKey)
  if (!_internal_has_privatekey()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.privatekey_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.privatekey_.IsDefault()) {
    _impl_.privatekey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void KeyPair::set_allocated_privatekey(std::string* privatekey) {
  if (privatekey != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.privatekey_.SetAllocated(privatekey, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.privatekey_.IsDefault()) {
    _impl_.privatekey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.KeyPair.privateKey)
}

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

// DataExtractionNotification

// required .SessionProtos.DataExtractionNotification.Type type = 1;
inline bool DataExtractionNotification::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool DataExtractionNotification::has_type() const {
  return _internal_has_type();
}
inline void DataExtractionNotification::clear_type() {
  _impl_.type_ = 1;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::SessionProtos::DataExtractionNotification_Type DataExtractionNotification::_internal_type() const {
  return static_cast< ::SessionProtos::DataExtractionNotification_Type >(_impl_.type_);
}
inline ::SessionProtos::DataExtractionNotification_Type DataExtractionNotification::type() const {
  // @@protoc_insertion_point(field_get:SessionProtos.DataExtractionNotification.type)
  return _internal_type();
}
inline void DataExtractionNotification::_internal_set_type(::SessionProtos::DataExtractionNotification_Type value) {
  assert(::SessionProtos::DataExtractionNotification_Type_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.type_ = value;
}
inline void DataExtractionNotification::set_type(::SessionProtos::DataExtractionNotification_Type value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:SessionProtos.DataExtractionNotification.type)
}

// optional uint64 timestamp = 2;
inline bool DataExtractionNotification::_internal_has_timestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool DataExtractionNotification::has_timestamp() const {
  return _internal_has_timestamp();
}
inline void DataExtractionNotification::clear_timestamp() {
  _impl_.timestamp_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t DataExtractionNotification::_internal_timestamp() const {
  return _impl_.timestamp_;
}
inline uint64_t DataExtractionNotification::timestamp() const {
  // @@protoc_insertion_point(field_get:SessionProtos.DataExtractionNotification.timestamp)
  return _internal_timestamp();
}
inline void DataExtractionNotification::_internal_set_timestamp(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.timestamp_ = value;
}
inline void DataExtractionNotification::set_timestamp(uint64_t value) {
  _internal_set_timestamp(value);
  // @@protoc_insertion_point(field_set:SessionProtos.DataExtractionNotification.timestamp)
}

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

// LokiProfile

// optional string displayName = 1;
inline bool LokiProfile::_internal_has_displayname() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool LokiProfile::has_displayname() const {
  return _internal_has_displayname();
}
inline void LokiProfile::clear_displayname() {
  _impl_.displayname_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& LokiProfile::displayname() const {
  // @@protoc_insertion_point(field_get:SessionProtos.LokiProfile.displayName)
  return _internal_displayname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LokiProfile::set_displayname(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.displayname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.LokiProfile.displayName)
}
inline std::string* LokiProfile::mutable_displayname() {
  std::string* _s = _internal_mutable_displayname();
  // @@protoc_insertion_point(field_mutable:SessionProtos.LokiProfile.displayName)
  return _s;
}
inline const std::string& LokiProfile::_internal_displayname() const {
  return _impl_.displayname_.Get();
}
inline void LokiProfile::_internal_set_displayname(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.displayname_.Set(value, GetArenaForAllocation());
}
inline std::string* LokiProfile::_internal_mutable_displayname() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.displayname_.Mutable(GetArenaForAllocation());
}
inline std::string* LokiProfile::release_displayname() {
  // @@protoc_insertion_point(field_release:SessionProtos.LokiProfile.displayName)
  if (!_internal_has_displayname()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.displayname_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.displayname_.IsDefault()) {
    _impl_.displayname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void LokiProfile::set_allocated_displayname(std::string* displayname) {
  if (displayname != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.displayname_.SetAllocated(displayname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.displayname_.IsDefault()) {
    _impl_.displayname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.LokiProfile.displayName)
}

// optional string profilePicture = 2;
inline bool LokiProfile::_internal_has_profilepicture() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool LokiProfile::has_profilepicture() const {
  return _internal_has_profilepicture();
}
inline void LokiProfile::clear_profilepicture() {
  _impl_.profilepicture_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& LokiProfile::profilepicture() const {
  // @@protoc_insertion_point(field_get:SessionProtos.LokiProfile.profilePicture)
  return _internal_profilepicture();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LokiProfile::set_profilepicture(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.profilepicture_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.LokiProfile.profilePicture)
}
inline std::string* LokiProfile::mutable_profilepicture() {
  std::string* _s = _internal_mutable_profilepicture();
  // @@protoc_insertion_point(field_mutable:SessionProtos.LokiProfile.profilePicture)
  return _s;
}
inline const std::string& LokiProfile::_internal_profilepicture() const {
  return _impl_.profilepicture_.Get();
}
inline void LokiProfile::_internal_set_profilepicture(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.profilepicture_.Set(value, GetArenaForAllocation());
}
inline std::string* LokiProfile::_internal_mutable_profilepicture() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.profilepicture_.Mutable(GetArenaForAllocation());
}
inline std::string* LokiProfile::release_profilepicture() {
  // @@protoc_insertion_point(field_release:SessionProtos.LokiProfile.profilePicture)
  if (!_internal_has_profilepicture()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.profilepicture_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.profilepicture_.IsDefault()) {
    _impl_.profilepicture_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void LokiProfile::set_allocated_profilepicture(std::string* profilepicture) {
  if (profilepicture != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.profilepicture_.SetAllocated(profilepicture, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.profilepicture_.IsDefault()) {
    _impl_.profilepicture_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.LokiProfile.profilePicture)
}

// optional uint64 lastUpdateSeconds = 3;
inline bool LokiProfile::_internal_has_lastupdateseconds() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool LokiProfile::has_lastupdateseconds() const {
  return _internal_has_lastupdateseconds();
}
inline void LokiProfile::clear_lastupdateseconds() {
  _impl_.lastupdateseconds_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint64_t LokiProfile::_internal_lastupdateseconds() const {
  return _impl_.lastupdateseconds_;
}
inline uint64_t LokiProfile::lastupdateseconds() const {
  // @@protoc_insertion_point(field_get:SessionProtos.LokiProfile.lastUpdateSeconds)
  return _internal_lastupdateseconds();
}
inline void LokiProfile::_internal_set_lastupdateseconds(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.lastupdateseconds_ = value;
}
inline void LokiProfile::set_lastupdateseconds(uint64_t value) {
  _internal_set_lastupdateseconds(value);
  // @@protoc_insertion_point(field_set:SessionProtos.LokiProfile.lastUpdateSeconds)
}

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

// DataMessage_Quote_QuotedAttachment

// optional string contentType = 1;
inline bool DataMessage_Quote_QuotedAttachment::_internal_has_contenttype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool DataMessage_Quote_QuotedAttachment::has_contenttype() const {
  return _internal_has_contenttype();
}
inline void DataMessage_Quote_QuotedAttachment::clear_contenttype() {
  _impl_.contenttype_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& DataMessage_Quote_QuotedAttachment::contenttype() const {
  // @@protoc_insertion_point(field_get:SessionProtos.DataMessage.Quote.QuotedAttachment.contentType)
  return _internal_contenttype();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DataMessage_Quote_QuotedAttachment::set_contenttype(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.contenttype_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.DataMessage.Quote.QuotedAttachment.contentType)
}
inline std::string* DataMessage_Quote_QuotedAttachment::mutable_contenttype() {
  std::string* _s = _internal_mutable_contenttype();
  // @@protoc_insertion_point(field_mutable:SessionProtos.DataMessage.Quote.QuotedAttachment.contentType)
  return _s;
}
inline const std::string& DataMessage_Quote_QuotedAttachment::_internal_contenttype() const {
  return _impl_.contenttype_.Get();
}
inline void DataMessage_Quote_QuotedAttachment::_internal_set_contenttype(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.contenttype_.Set(value, GetArenaForAllocation());
}
inline std::string* DataMessage_Quote_QuotedAttachment::_internal_mutable_contenttype() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.contenttype_.Mutable(GetArenaForAllocation());
}
inline std::string* DataMessage_Quote_QuotedAttachment::release_contenttype() {
  // @@protoc_insertion_point(field_release:SessionProtos.DataMessage.Quote.QuotedAttachment.contentType)
  if (!_internal_has_contenttype()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.contenttype_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.contenttype_.IsDefault()) {
    _impl_.contenttype_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void DataMessage_Quote_QuotedAttachment::set_allocated_contenttype(std::string* contenttype) {
  if (contenttype != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.contenttype_.SetAllocated(contenttype, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.contenttype_.IsDefault()) {
    _impl_.contenttype_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.DataMessage.Quote.QuotedAttachment.contentType)
}

// optional string fileName = 2;
inline bool DataMessage_Quote_QuotedAttachment::_internal_has_filename() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool DataMessage_Quote_QuotedAttachment::has_filename() const {
  return _internal_has_filename();
}
inline void DataMessage_Quote_QuotedAttachment::clear_filename() {
  _impl_.filename_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& DataMessage_Quote_QuotedAttachment::filename() const {
  // @@protoc_insertion_point(field_get:SessionProtos.DataMessage.Quote.QuotedAttachment.fileName)
  return _internal_filename();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DataMessage_Quote_QuotedAttachment::set_filename(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.filename_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.DataMessage.Quote.QuotedAttachment.fileName)
}
inline std::string* DataMessage_Quote_QuotedAttachment::mutable_filename() {
  std::string* _s = _internal_mutable_filename();
  // @@protoc_insertion_point(field_mutable:SessionProtos.DataMessage.Quote.QuotedAttachment.fileName)
  return _s;
}
inline const std::string& DataMessage_Quote_QuotedAttachment::_internal_filename() const {
  return _impl_.filename_.Get();
}
inline void DataMessage_Quote_QuotedAttachment::_internal_set_filename(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.filename_.Set(value, GetArenaForAllocation());
}
inline std::string* DataMessage_Quote_QuotedAttachment::_internal_mutable_filename() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.filename_.Mutable(GetArenaForAllocation());
}
inline std::string* DataMessage_Quote_QuotedAttachment::release_filename() {
  // @@protoc_insertion_point(field_release:SessionProtos.DataMessage.Quote.QuotedAttachment.fileName)
  if (!_internal_has_filename()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.filename_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.filename_.IsDefault()) {
    _impl_.filename_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void DataMessage_Quote_QuotedAttachment::set_allocated_filename(std::string* filename) {
  if (filename != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.filename_.SetAllocated(filename, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.filename_.IsDefault()) {
    _impl_.filename_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.DataMessage.Quote.QuotedAttachment.fileName)
}

// optional .SessionProtos.AttachmentPointer thumbnail = 3;
inline bool DataMessage_Quote_QuotedAttachment::_internal_has_thumbnail() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.thumbnail_ != nullptr);
  return value;
}
inline bool DataMessage_Quote_QuotedAttachment::has_thumbnail() const {
  return _internal_has_thumbnail();
}
inline void DataMessage_Quote_QuotedAttachment::clear_thumbnail() {
  if (_impl_.thumbnail_ != nullptr) _impl_.thumbnail_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::SessionProtos::AttachmentPointer& DataMessage_Quote_QuotedAttachment::_internal_thumbnail() const {
  const ::SessionProtos::AttachmentPointer* p = _impl_.thumbnail_;
  return p != nullptr ? *p : reinterpret_cast<const ::SessionProtos::AttachmentPointer&>(
      ::SessionProtos::_AttachmentPointer_default_instance_);
}
inline const ::SessionProtos::AttachmentPointer& DataMessage_Quote_QuotedAttachment::thumbnail() const {
  // @@protoc_insertion_point(field_get:SessionProtos.DataMessage.Quote.QuotedAttachment.thumbnail)
  return _internal_thumbnail();
}
inline void DataMessage_Quote_QuotedAttachment::unsafe_arena_set_allocated_thumbnail(
    ::SessionProtos::AttachmentPointer* thumbnail) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.thumbnail_);
  }
  _impl_.thumbnail_ = thumbnail;
  if (thumbnail) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:SessionProtos.DataMessage.Quote.QuotedAttachment.thumbnail)
}
inline ::SessionProtos::AttachmentPointer* DataMessage_Quote_QuotedAttachment::release_thumbnail() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::SessionProtos::AttachmentPointer* temp = _impl_.thumbnail_;
  _impl_.thumbnail_ = 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 ::SessionProtos::AttachmentPointer* DataMessage_Quote_QuotedAttachment::unsafe_arena_release_thumbnail() {
  // @@protoc_insertion_point(field_release:SessionProtos.DataMessage.Quote.QuotedAttachment.thumbnail)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::SessionProtos::AttachmentPointer* temp = _impl_.thumbnail_;
  _impl_.thumbnail_ = nullptr;
  return temp;
}
inline ::SessionProtos::AttachmentPointer* DataMessage_Quote_QuotedAttachment::_internal_mutable_thumbnail() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.thumbnail_ == nullptr) {
    auto* p = CreateMaybeMessage<::SessionProtos::AttachmentPointer>(GetArenaForAllocation());
    _impl_.thumbnail_ = p;
  }
  return _impl_.thumbnail_;
}
inline ::SessionProtos::AttachmentPointer* DataMessage_Quote_QuotedAttachment::mutable_thumbnail() {
  ::SessionProtos::AttachmentPointer* _msg = _internal_mutable_thumbnail();
  // @@protoc_insertion_point(field_mutable:SessionProtos.DataMessage.Quote.QuotedAttachment.thumbnail)
  return _msg;
}
inline void DataMessage_Quote_QuotedAttachment::set_allocated_thumbnail(::SessionProtos::AttachmentPointer* thumbnail) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.thumbnail_;
  }
  if (thumbnail) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(thumbnail);
    if (message_arena != submessage_arena) {
      thumbnail = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, thumbnail, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.thumbnail_ = thumbnail;
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.DataMessage.Quote.QuotedAttachment.thumbnail)
}

// optional uint32 flags = 4;
inline bool DataMessage_Quote_QuotedAttachment::_internal_has_flags() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool DataMessage_Quote_QuotedAttachment::has_flags() const {
  return _internal_has_flags();
}
inline void DataMessage_Quote_QuotedAttachment::clear_flags() {
  _impl_.flags_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t DataMessage_Quote_QuotedAttachment::_internal_flags() const {
  return _impl_.flags_;
}
inline uint32_t DataMessage_Quote_QuotedAttachment::flags() const {
  // @@protoc_insertion_point(field_get:SessionProtos.DataMessage.Quote.QuotedAttachment.flags)
  return _internal_flags();
}
inline void DataMessage_Quote_QuotedAttachment::_internal_set_flags(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.flags_ = value;
}
inline void DataMessage_Quote_QuotedAttachment::set_flags(uint32_t value) {
  _internal_set_flags(value);
  // @@protoc_insertion_point(field_set:SessionProtos.DataMessage.Quote.QuotedAttachment.flags)
}

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

// DataMessage_Quote

// required uint64 id = 1;
inline bool DataMessage_Quote::_internal_has_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool DataMessage_Quote::has_id() const {
  return _internal_has_id();
}
inline void DataMessage_Quote::clear_id() {
  _impl_.id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint64_t DataMessage_Quote::_internal_id() const {
  return _impl_.id_;
}
inline uint64_t DataMessage_Quote::id() const {
  // @@protoc_insertion_point(field_get:SessionProtos.DataMessage.Quote.id)
  return _internal_id();
}
inline void DataMessage_Quote::_internal_set_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.id_ = value;
}
inline void DataMessage_Quote::set_id(uint64_t value) {
  _internal_set_id(value);
  // @@protoc_insertion_point(field_set:SessionProtos.DataMessage.Quote.id)
}

// required string author = 2;
inline bool DataMessage_Quote::_internal_has_author() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool DataMessage_Quote::has_author() const {
  return _internal_has_author();
}
inline void DataMessage_Quote::clear_author() {
  _impl_.author_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& DataMessage_Quote::author() const {
  // @@protoc_insertion_point(field_get:SessionProtos.DataMessage.Quote.author)
  return _internal_author();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DataMessage_Quote::set_author(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.author_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.DataMessage.Quote.author)
}
inline std::string* DataMessage_Quote::mutable_author() {
  std::string* _s = _internal_mutable_author();
  // @@protoc_insertion_point(field_mutable:SessionProtos.DataMessage.Quote.author)
  return _s;
}
inline const std::string& DataMessage_Quote::_internal_author() const {
  return _impl_.author_.Get();
}
inline void DataMessage_Quote::_internal_set_author(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.author_.Set(value, GetArenaForAllocation());
}
inline std::string* DataMessage_Quote::_internal_mutable_author() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.author_.Mutable(GetArenaForAllocation());
}
inline std::string* DataMessage_Quote::release_author() {
  // @@protoc_insertion_point(field_release:SessionProtos.DataMessage.Quote.author)
  if (!_internal_has_author()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.author_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.author_.IsDefault()) {
    _impl_.author_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void DataMessage_Quote::set_allocated_author(std::string* author) {
  if (author != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.author_.SetAllocated(author, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.author_.IsDefault()) {
    _impl_.author_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.DataMessage.Quote.author)
}

// optional string text = 3;
inline bool DataMessage_Quote::_internal_has_text() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool DataMessage_Quote::has_text() const {
  return _internal_has_text();
}
inline void DataMessage_Quote::clear_text() {
  _impl_.text_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& DataMessage_Quote::text() const {
  // @@protoc_insertion_point(field_get:SessionProtos.DataMessage.Quote.text)
  return _internal_text();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DataMessage_Quote::set_text(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.text_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.DataMessage.Quote.text)
}
inline std::string* DataMessage_Quote::mutable_text() {
  std::string* _s = _internal_mutable_text();
  // @@protoc_insertion_point(field_mutable:SessionProtos.DataMessage.Quote.text)
  return _s;
}
inline const std::string& DataMessage_Quote::_internal_text() const {
  return _impl_.text_.Get();
}
inline void DataMessage_Quote::_internal_set_text(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.text_.Set(value, GetArenaForAllocation());
}
inline std::string* DataMessage_Quote::_internal_mutable_text() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.text_.Mutable(GetArenaForAllocation());
}
inline std::string* DataMessage_Quote::release_text() {
  // @@protoc_insertion_point(field_release:SessionProtos.DataMessage.Quote.text)
  if (!_internal_has_text()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.text_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.text_.IsDefault()) {
    _impl_.text_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void DataMessage_Quote::set_allocated_text(std::string* text) {
  if (text != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.text_.SetAllocated(text, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.text_.IsDefault()) {
    _impl_.text_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.DataMessage.Quote.text)
}

// repeated .SessionProtos.DataMessage.Quote.QuotedAttachment attachments = 4;
inline int DataMessage_Quote::_internal_attachments_size() const {
  return _impl_.attachments_.size();
}
inline int DataMessage_Quote::attachments_size() const {
  return _internal_attachments_size();
}
inline void DataMessage_Quote::clear_attachments() {
  _impl_.attachments_.Clear();
}
inline ::SessionProtos::DataMessage_Quote_QuotedAttachment* DataMessage_Quote::mutable_attachments(int index) {
  // @@protoc_insertion_point(field_mutable:SessionProtos.DataMessage.Quote.attachments)
  return _impl_.attachments_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SessionProtos::DataMessage_Quote_QuotedAttachment >*
DataMessage_Quote::mutable_attachments() {
  // @@protoc_insertion_point(field_mutable_list:SessionProtos.DataMessage.Quote.attachments)
  return &_impl_.attachments_;
}
inline const ::SessionProtos::DataMessage_Quote_QuotedAttachment& DataMessage_Quote::_internal_attachments(int index) const {
  return _impl_.attachments_.Get(index);
}
inline const ::SessionProtos::DataMessage_Quote_QuotedAttachment& DataMessage_Quote::attachments(int index) const {
  // @@protoc_insertion_point(field_get:SessionProtos.DataMessage.Quote.attachments)
  return _internal_attachments(index);
}
inline ::SessionProtos::DataMessage_Quote_QuotedAttachment* DataMessage_Quote::_internal_add_attachments() {
  return _impl_.attachments_.Add();
}
inline ::SessionProtos::DataMessage_Quote_QuotedAttachment* DataMessage_Quote::add_attachments() {
  ::SessionProtos::DataMessage_Quote_QuotedAttachment* _add = _internal_add_attachments();
  // @@protoc_insertion_point(field_add:SessionProtos.DataMessage.Quote.attachments)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SessionProtos::DataMessage_Quote_QuotedAttachment >&
DataMessage_Quote::attachments() const {
  // @@protoc_insertion_point(field_list:SessionProtos.DataMessage.Quote.attachments)
  return _impl_.attachments_;
}

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

// DataMessage_Preview

// required string url = 1;
inline bool DataMessage_Preview::_internal_has_url() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool DataMessage_Preview::has_url() const {
  return _internal_has_url();
}
inline void DataMessage_Preview::clear_url() {
  _impl_.url_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& DataMessage_Preview::url() const {
  // @@protoc_insertion_point(field_get:SessionProtos.DataMessage.Preview.url)
  return _internal_url();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DataMessage_Preview::set_url(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.DataMessage.Preview.url)
}
inline std::string* DataMessage_Preview::mutable_url() {
  std::string* _s = _internal_mutable_url();
  // @@protoc_insertion_point(field_mutable:SessionProtos.DataMessage.Preview.url)
  return _s;
}
inline const std::string& DataMessage_Preview::_internal_url() const {
  return _impl_.url_.Get();
}
inline void DataMessage_Preview::_internal_set_url(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.url_.Set(value, GetArenaForAllocation());
}
inline std::string* DataMessage_Preview::_internal_mutable_url() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.url_.Mutable(GetArenaForAllocation());
}
inline std::string* DataMessage_Preview::release_url() {
  // @@protoc_insertion_point(field_release:SessionProtos.DataMessage.Preview.url)
  if (!_internal_has_url()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.url_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.url_.IsDefault()) {
    _impl_.url_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void DataMessage_Preview::set_allocated_url(std::string* url) {
  if (url != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.url_.SetAllocated(url, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.url_.IsDefault()) {
    _impl_.url_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.DataMessage.Preview.url)
}

// optional string title = 2;
inline bool DataMessage_Preview::_internal_has_title() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool DataMessage_Preview::has_title() const {
  return _internal_has_title();
}
inline void DataMessage_Preview::clear_title() {
  _impl_.title_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& DataMessage_Preview::title() const {
  // @@protoc_insertion_point(field_get:SessionProtos.DataMessage.Preview.title)
  return _internal_title();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DataMessage_Preview::set_title(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.title_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.DataMessage.Preview.title)
}
inline std::string* DataMessage_Preview::mutable_title() {
  std::string* _s = _internal_mutable_title();
  // @@protoc_insertion_point(field_mutable:SessionProtos.DataMessage.Preview.title)
  return _s;
}
inline const std::string& DataMessage_Preview::_internal_title() const {
  return _impl_.title_.Get();
}
inline void DataMessage_Preview::_internal_set_title(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.title_.Set(value, GetArenaForAllocation());
}
inline std::string* DataMessage_Preview::_internal_mutable_title() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.title_.Mutable(GetArenaForAllocation());
}
inline std::string* DataMessage_Preview::release_title() {
  // @@protoc_insertion_point(field_release:SessionProtos.DataMessage.Preview.title)
  if (!_internal_has_title()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.title_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.title_.IsDefault()) {
    _impl_.title_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void DataMessage_Preview::set_allocated_title(std::string* title) {
  if (title != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.title_.SetAllocated(title, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.title_.IsDefault()) {
    _impl_.title_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.DataMessage.Preview.title)
}

// optional .SessionProtos.AttachmentPointer image = 3;
inline bool DataMessage_Preview::_internal_has_image() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.image_ != nullptr);
  return value;
}
inline bool DataMessage_Preview::has_image() const {
  return _internal_has_image();
}
inline void DataMessage_Preview::clear_image() {
  if (_impl_.image_ != nullptr) _impl_.image_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::SessionProtos::AttachmentPointer& DataMessage_Preview::_internal_image() const {
  const ::SessionProtos::AttachmentPointer* p = _impl_.image_;
  return p != nullptr ? *p : reinterpret_cast<const ::SessionProtos::AttachmentPointer&>(
      ::SessionProtos::_AttachmentPointer_default_instance_);
}
inline const ::SessionProtos::AttachmentPointer& DataMessage_Preview::image() const {
  // @@protoc_insertion_point(field_get:SessionProtos.DataMessage.Preview.image)
  return _internal_image();
}
inline void DataMessage_Preview::unsafe_arena_set_allocated_image(
    ::SessionProtos::AttachmentPointer* image) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.image_);
  }
  _impl_.image_ = image;
  if (image) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:SessionProtos.DataMessage.Preview.image)
}
inline ::SessionProtos::AttachmentPointer* DataMessage_Preview::release_image() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::SessionProtos::AttachmentPointer* temp = _impl_.image_;
  _impl_.image_ = 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 ::SessionProtos::AttachmentPointer* DataMessage_Preview::unsafe_arena_release_image() {
  // @@protoc_insertion_point(field_release:SessionProtos.DataMessage.Preview.image)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::SessionProtos::AttachmentPointer* temp = _impl_.image_;
  _impl_.image_ = nullptr;
  return temp;
}
inline ::SessionProtos::AttachmentPointer* DataMessage_Preview::_internal_mutable_image() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.image_ == nullptr) {
    auto* p = CreateMaybeMessage<::SessionProtos::AttachmentPointer>(GetArenaForAllocation());
    _impl_.image_ = p;
  }
  return _impl_.image_;
}
inline ::SessionProtos::AttachmentPointer* DataMessage_Preview::mutable_image() {
  ::SessionProtos::AttachmentPointer* _msg = _internal_mutable_image();
  // @@protoc_insertion_point(field_mutable:SessionProtos.DataMessage.Preview.image)
  return _msg;
}
inline void DataMessage_Preview::set_allocated_image(::SessionProtos::AttachmentPointer* image) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.image_;
  }
  if (image) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(image);
    if (message_arena != submessage_arena) {
      image = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, image, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.image_ = image;
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.DataMessage.Preview.image)
}

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

// DataMessage_Reaction

// required uint64 id = 1;
inline bool DataMessage_Reaction::_internal_has_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool DataMessage_Reaction::has_id() const {
  return _internal_has_id();
}
inline void DataMessage_Reaction::clear_id() {
  _impl_.id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint64_t DataMessage_Reaction::_internal_id() const {
  return _impl_.id_;
}
inline uint64_t DataMessage_Reaction::id() const {
  // @@protoc_insertion_point(field_get:SessionProtos.DataMessage.Reaction.id)
  return _internal_id();
}
inline void DataMessage_Reaction::_internal_set_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.id_ = value;
}
inline void DataMessage_Reaction::set_id(uint64_t value) {
  _internal_set_id(value);
  // @@protoc_insertion_point(field_set:SessionProtos.DataMessage.Reaction.id)
}

// required string author = 2;
inline bool DataMessage_Reaction::_internal_has_author() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool DataMessage_Reaction::has_author() const {
  return _internal_has_author();
}
inline void DataMessage_Reaction::clear_author() {
  _impl_.author_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& DataMessage_Reaction::author() const {
  // @@protoc_insertion_point(field_get:SessionProtos.DataMessage.Reaction.author)
  return _internal_author();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DataMessage_Reaction::set_author(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.author_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.DataMessage.Reaction.author)
}
inline std::string* DataMessage_Reaction::mutable_author() {
  std::string* _s = _internal_mutable_author();
  // @@protoc_insertion_point(field_mutable:SessionProtos.DataMessage.Reaction.author)
  return _s;
}
inline const std::string& DataMessage_Reaction::_internal_author() const {
  return _impl_.author_.Get();
}
inline void DataMessage_Reaction::_internal_set_author(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.author_.Set(value, GetArenaForAllocation());
}
inline std::string* DataMessage_Reaction::_internal_mutable_author() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.author_.Mutable(GetArenaForAllocation());
}
inline std::string* DataMessage_Reaction::release_author() {
  // @@protoc_insertion_point(field_release:SessionProtos.DataMessage.Reaction.author)
  if (!_internal_has_author()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.author_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.author_.IsDefault()) {
    _impl_.author_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void DataMessage_Reaction::set_allocated_author(std::string* author) {
  if (author != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.author_.SetAllocated(author, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.author_.IsDefault()) {
    _impl_.author_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.DataMessage.Reaction.author)
}

// optional string emoji = 3;
inline bool DataMessage_Reaction::_internal_has_emoji() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool DataMessage_Reaction::has_emoji() const {
  return _internal_has_emoji();
}
inline void DataMessage_Reaction::clear_emoji() {
  _impl_.emoji_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& DataMessage_Reaction::emoji() const {
  // @@protoc_insertion_point(field_get:SessionProtos.DataMessage.Reaction.emoji)
  return _internal_emoji();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DataMessage_Reaction::set_emoji(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.emoji_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.DataMessage.Reaction.emoji)
}
inline std::string* DataMessage_Reaction::mutable_emoji() {
  std::string* _s = _internal_mutable_emoji();
  // @@protoc_insertion_point(field_mutable:SessionProtos.DataMessage.Reaction.emoji)
  return _s;
}
inline const std::string& DataMessage_Reaction::_internal_emoji() const {
  return _impl_.emoji_.Get();
}
inline void DataMessage_Reaction::_internal_set_emoji(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.emoji_.Set(value, GetArenaForAllocation());
}
inline std::string* DataMessage_Reaction::_internal_mutable_emoji() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.emoji_.Mutable(GetArenaForAllocation());
}
inline std::string* DataMessage_Reaction::release_emoji() {
  // @@protoc_insertion_point(field_release:SessionProtos.DataMessage.Reaction.emoji)
  if (!_internal_has_emoji()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.emoji_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.emoji_.IsDefault()) {
    _impl_.emoji_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void DataMessage_Reaction::set_allocated_emoji(std::string* emoji) {
  if (emoji != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.emoji_.SetAllocated(emoji, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.emoji_.IsDefault()) {
    _impl_.emoji_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.DataMessage.Reaction.emoji)
}

// required .SessionProtos.DataMessage.Reaction.Action action = 4;
inline bool DataMessage_Reaction::_internal_has_action() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool DataMessage_Reaction::has_action() const {
  return _internal_has_action();
}
inline void DataMessage_Reaction::clear_action() {
  _impl_.action_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline ::SessionProtos::DataMessage_Reaction_Action DataMessage_Reaction::_internal_action() const {
  return static_cast< ::SessionProtos::DataMessage_Reaction_Action >(_impl_.action_);
}
inline ::SessionProtos::DataMessage_Reaction_Action DataMessage_Reaction::action() const {
  // @@protoc_insertion_point(field_get:SessionProtos.DataMessage.Reaction.action)
  return _internal_action();
}
inline void DataMessage_Reaction::_internal_set_action(::SessionProtos::DataMessage_Reaction_Action value) {
  assert(::SessionProtos::DataMessage_Reaction_Action_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.action_ = value;
}
inline void DataMessage_Reaction::set_action(::SessionProtos::DataMessage_Reaction_Action value) {
  _internal_set_action(value);
  // @@protoc_insertion_point(field_set:SessionProtos.DataMessage.Reaction.action)
}

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

// DataMessage_OpenGroupInvitation

// required string url = 1;
inline bool DataMessage_OpenGroupInvitation::_internal_has_url() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool DataMessage_OpenGroupInvitation::has_url() const {
  return _internal_has_url();
}
inline void DataMessage_OpenGroupInvitation::clear_url() {
  _impl_.url_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& DataMessage_OpenGroupInvitation::url() const {
  // @@protoc_insertion_point(field_get:SessionProtos.DataMessage.OpenGroupInvitation.url)
  return _internal_url();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DataMessage_OpenGroupInvitation::set_url(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.DataMessage.OpenGroupInvitation.url)
}
inline std::string* DataMessage_OpenGroupInvitation::mutable_url() {
  std::string* _s = _internal_mutable_url();
  // @@protoc_insertion_point(field_mutable:SessionProtos.DataMessage.OpenGroupInvitation.url)
  return _s;
}
inline const std::string& DataMessage_OpenGroupInvitation::_internal_url() const {
  return _impl_.url_.Get();
}
inline void DataMessage_OpenGroupInvitation::_internal_set_url(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.url_.Set(value, GetArenaForAllocation());
}
inline std::string* DataMessage_OpenGroupInvitation::_internal_mutable_url() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.url_.Mutable(GetArenaForAllocation());
}
inline std::string* DataMessage_OpenGroupInvitation::release_url() {
  // @@protoc_insertion_point(field_release:SessionProtos.DataMessage.OpenGroupInvitation.url)
  if (!_internal_has_url()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.url_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.url_.IsDefault()) {
    _impl_.url_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void DataMessage_OpenGroupInvitation::set_allocated_url(std::string* url) {
  if (url != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.url_.SetAllocated(url, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.url_.IsDefault()) {
    _impl_.url_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.DataMessage.OpenGroupInvitation.url)
}

// required string name = 3;
inline bool DataMessage_OpenGroupInvitation::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool DataMessage_OpenGroupInvitation::has_name() const {
  return _internal_has_name();
}
inline void DataMessage_OpenGroupInvitation::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& DataMessage_OpenGroupInvitation::name() const {
  // @@protoc_insertion_point(field_get:SessionProtos.DataMessage.OpenGroupInvitation.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DataMessage_OpenGroupInvitation::set_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.DataMessage.OpenGroupInvitation.name)
}
inline std::string* DataMessage_OpenGroupInvitation::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:SessionProtos.DataMessage.OpenGroupInvitation.name)
  return _s;
}
inline const std::string& DataMessage_OpenGroupInvitation::_internal_name() const {
  return _impl_.name_.Get();
}
inline void DataMessage_OpenGroupInvitation::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* DataMessage_OpenGroupInvitation::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* DataMessage_OpenGroupInvitation::release_name() {
  // @@protoc_insertion_point(field_release:SessionProtos.DataMessage.OpenGroupInvitation.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void DataMessage_OpenGroupInvitation::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.DataMessage.OpenGroupInvitation.name)
}

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

// DataMessage

// optional string body = 1;
inline bool DataMessage::_internal_has_body() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool DataMessage::has_body() const {
  return _internal_has_body();
}
inline void DataMessage::clear_body() {
  _impl_.body_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& DataMessage::body() const {
  // @@protoc_insertion_point(field_get:SessionProtos.DataMessage.body)
  return _internal_body();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DataMessage::set_body(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.body_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.DataMessage.body)
}
inline std::string* DataMessage::mutable_body() {
  std::string* _s = _internal_mutable_body();
  // @@protoc_insertion_point(field_mutable:SessionProtos.DataMessage.body)
  return _s;
}
inline const std::string& DataMessage::_internal_body() const {
  return _impl_.body_.Get();
}
inline void DataMessage::_internal_set_body(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.body_.Set(value, GetArenaForAllocation());
}
inline std::string* DataMessage::_internal_mutable_body() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.body_.Mutable(GetArenaForAllocation());
}
inline std::string* DataMessage::release_body() {
  // @@protoc_insertion_point(field_release:SessionProtos.DataMessage.body)
  if (!_internal_has_body()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.body_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.body_.IsDefault()) {
    _impl_.body_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void DataMessage::set_allocated_body(std::string* body) {
  if (body != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.body_.SetAllocated(body, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.body_.IsDefault()) {
    _impl_.body_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.DataMessage.body)
}

// repeated .SessionProtos.AttachmentPointer attachments = 2;
inline int DataMessage::_internal_attachments_size() const {
  return _impl_.attachments_.size();
}
inline int DataMessage::attachments_size() const {
  return _internal_attachments_size();
}
inline void DataMessage::clear_attachments() {
  _impl_.attachments_.Clear();
}
inline ::SessionProtos::AttachmentPointer* DataMessage::mutable_attachments(int index) {
  // @@protoc_insertion_point(field_mutable:SessionProtos.DataMessage.attachments)
  return _impl_.attachments_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SessionProtos::AttachmentPointer >*
DataMessage::mutable_attachments() {
  // @@protoc_insertion_point(field_mutable_list:SessionProtos.DataMessage.attachments)
  return &_impl_.attachments_;
}
inline const ::SessionProtos::AttachmentPointer& DataMessage::_internal_attachments(int index) const {
  return _impl_.attachments_.Get(index);
}
inline const ::SessionProtos::AttachmentPointer& DataMessage::attachments(int index) const {
  // @@protoc_insertion_point(field_get:SessionProtos.DataMessage.attachments)
  return _internal_attachments(index);
}
inline ::SessionProtos::AttachmentPointer* DataMessage::_internal_add_attachments() {
  return _impl_.attachments_.Add();
}
inline ::SessionProtos::AttachmentPointer* DataMessage::add_attachments() {
  ::SessionProtos::AttachmentPointer* _add = _internal_add_attachments();
  // @@protoc_insertion_point(field_add:SessionProtos.DataMessage.attachments)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SessionProtos::AttachmentPointer >&
DataMessage::attachments() const {
  // @@protoc_insertion_point(field_list:SessionProtos.DataMessage.attachments)
  return _impl_.attachments_;
}

// optional uint32 flags = 4;
inline bool DataMessage::_internal_has_flags() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool DataMessage::has_flags() const {
  return _internal_has_flags();
}
inline void DataMessage::clear_flags() {
  _impl_.flags_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint32_t DataMessage::_internal_flags() const {
  return _impl_.flags_;
}
inline uint32_t DataMessage::flags() const {
  // @@protoc_insertion_point(field_get:SessionProtos.DataMessage.flags)
  return _internal_flags();
}
inline void DataMessage::_internal_set_flags(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.flags_ = value;
}
inline void DataMessage::set_flags(uint32_t value) {
  _internal_set_flags(value);
  // @@protoc_insertion_point(field_set:SessionProtos.DataMessage.flags)
}

// optional bytes profileKey = 6;
inline bool DataMessage::_internal_has_profilekey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool DataMessage::has_profilekey() const {
  return _internal_has_profilekey();
}
inline void DataMessage::clear_profilekey() {
  _impl_.profilekey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& DataMessage::profilekey() const {
  // @@protoc_insertion_point(field_get:SessionProtos.DataMessage.profileKey)
  return _internal_profilekey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DataMessage::set_profilekey(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.profilekey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.DataMessage.profileKey)
}
inline std::string* DataMessage::mutable_profilekey() {
  std::string* _s = _internal_mutable_profilekey();
  // @@protoc_insertion_point(field_mutable:SessionProtos.DataMessage.profileKey)
  return _s;
}
inline const std::string& DataMessage::_internal_profilekey() const {
  return _impl_.profilekey_.Get();
}
inline void DataMessage::_internal_set_profilekey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.profilekey_.Set(value, GetArenaForAllocation());
}
inline std::string* DataMessage::_internal_mutable_profilekey() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.profilekey_.Mutable(GetArenaForAllocation());
}
inline std::string* DataMessage::release_profilekey() {
  // @@protoc_insertion_point(field_release:SessionProtos.DataMessage.profileKey)
  if (!_internal_has_profilekey()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.profilekey_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.profilekey_.IsDefault()) {
    _impl_.profilekey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void DataMessage::set_allocated_profilekey(std::string* profilekey) {
  if (profilekey != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.profilekey_.SetAllocated(profilekey, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.profilekey_.IsDefault()) {
    _impl_.profilekey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.DataMessage.profileKey)
}

// optional uint64 timestamp = 7;
inline bool DataMessage::_internal_has_timestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool DataMessage::has_timestamp() const {
  return _internal_has_timestamp();
}
inline void DataMessage::clear_timestamp() {
  _impl_.timestamp_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint64_t DataMessage::_internal_timestamp() const {
  return _impl_.timestamp_;
}
inline uint64_t DataMessage::timestamp() const {
  // @@protoc_insertion_point(field_get:SessionProtos.DataMessage.timestamp)
  return _internal_timestamp();
}
inline void DataMessage::_internal_set_timestamp(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.timestamp_ = value;
}
inline void DataMessage::set_timestamp(uint64_t value) {
  _internal_set_timestamp(value);
  // @@protoc_insertion_point(field_set:SessionProtos.DataMessage.timestamp)
}

// optional .SessionProtos.DataMessage.Quote quote = 8;
inline bool DataMessage::_internal_has_quote() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.quote_ != nullptr);
  return value;
}
inline bool DataMessage::has_quote() const {
  return _internal_has_quote();
}
inline void DataMessage::clear_quote() {
  if (_impl_.quote_ != nullptr) _impl_.quote_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::SessionProtos::DataMessage_Quote& DataMessage::_internal_quote() const {
  const ::SessionProtos::DataMessage_Quote* p = _impl_.quote_;
  return p != nullptr ? *p : reinterpret_cast<const ::SessionProtos::DataMessage_Quote&>(
      ::SessionProtos::_DataMessage_Quote_default_instance_);
}
inline const ::SessionProtos::DataMessage_Quote& DataMessage::quote() const {
  // @@protoc_insertion_point(field_get:SessionProtos.DataMessage.quote)
  return _internal_quote();
}
inline void DataMessage::unsafe_arena_set_allocated_quote(
    ::SessionProtos::DataMessage_Quote* quote) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quote_);
  }
  _impl_.quote_ = quote;
  if (quote) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:SessionProtos.DataMessage.quote)
}
inline ::SessionProtos::DataMessage_Quote* DataMessage::release_quote() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::SessionProtos::DataMessage_Quote* temp = _impl_.quote_;
  _impl_.quote_ = 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 ::SessionProtos::DataMessage_Quote* DataMessage::unsafe_arena_release_quote() {
  // @@protoc_insertion_point(field_release:SessionProtos.DataMessage.quote)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::SessionProtos::DataMessage_Quote* temp = _impl_.quote_;
  _impl_.quote_ = nullptr;
  return temp;
}
inline ::SessionProtos::DataMessage_Quote* DataMessage::_internal_mutable_quote() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.quote_ == nullptr) {
    auto* p = CreateMaybeMessage<::SessionProtos::DataMessage_Quote>(GetArenaForAllocation());
    _impl_.quote_ = p;
  }
  return _impl_.quote_;
}
inline ::SessionProtos::DataMessage_Quote* DataMessage::mutable_quote() {
  ::SessionProtos::DataMessage_Quote* _msg = _internal_mutable_quote();
  // @@protoc_insertion_point(field_mutable:SessionProtos.DataMessage.quote)
  return _msg;
}
inline void DataMessage::set_allocated_quote(::SessionProtos::DataMessage_Quote* quote) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.quote_;
  }
  if (quote) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(quote);
    if (message_arena != submessage_arena) {
      quote = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quote, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.quote_ = quote;
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.DataMessage.quote)
}

// repeated .SessionProtos.DataMessage.Preview preview = 10;
inline int DataMessage::_internal_preview_size() const {
  return _impl_.preview_.size();
}
inline int DataMessage::preview_size() const {
  return _internal_preview_size();
}
inline void DataMessage::clear_preview() {
  _impl_.preview_.Clear();
}
inline ::SessionProtos::DataMessage_Preview* DataMessage::mutable_preview(int index) {
  // @@protoc_insertion_point(field_mutable:SessionProtos.DataMessage.preview)
  return _impl_.preview_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SessionProtos::DataMessage_Preview >*
DataMessage::mutable_preview() {
  // @@protoc_insertion_point(field_mutable_list:SessionProtos.DataMessage.preview)
  return &_impl_.preview_;
}
inline const ::SessionProtos::DataMessage_Preview& DataMessage::_internal_preview(int index) const {
  return _impl_.preview_.Get(index);
}
inline const ::SessionProtos::DataMessage_Preview& DataMessage::preview(int index) const {
  // @@protoc_insertion_point(field_get:SessionProtos.DataMessage.preview)
  return _internal_preview(index);
}
inline ::SessionProtos::DataMessage_Preview* DataMessage::_internal_add_preview() {
  return _impl_.preview_.Add();
}
inline ::SessionProtos::DataMessage_Preview* DataMessage::add_preview() {
  ::SessionProtos::DataMessage_Preview* _add = _internal_add_preview();
  // @@protoc_insertion_point(field_add:SessionProtos.DataMessage.preview)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SessionProtos::DataMessage_Preview >&
DataMessage::preview() const {
  // @@protoc_insertion_point(field_list:SessionProtos.DataMessage.preview)
  return _impl_.preview_;
}

// optional .SessionProtos.DataMessage.Reaction reaction = 11;
inline bool DataMessage::_internal_has_reaction() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.reaction_ != nullptr);
  return value;
}
inline bool DataMessage::has_reaction() const {
  return _internal_has_reaction();
}
inline void DataMessage::clear_reaction() {
  if (_impl_.reaction_ != nullptr) _impl_.reaction_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const ::SessionProtos::DataMessage_Reaction& DataMessage::_internal_reaction() const {
  const ::SessionProtos::DataMessage_Reaction* p = _impl_.reaction_;
  return p != nullptr ? *p : reinterpret_cast<const ::SessionProtos::DataMessage_Reaction&>(
      ::SessionProtos::_DataMessage_Reaction_default_instance_);
}
inline const ::SessionProtos::DataMessage_Reaction& DataMessage::reaction() const {
  // @@protoc_insertion_point(field_get:SessionProtos.DataMessage.reaction)
  return _internal_reaction();
}
inline void DataMessage::unsafe_arena_set_allocated_reaction(
    ::SessionProtos::DataMessage_Reaction* reaction) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.reaction_);
  }
  _impl_.reaction_ = reaction;
  if (reaction) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:SessionProtos.DataMessage.reaction)
}
inline ::SessionProtos::DataMessage_Reaction* DataMessage::release_reaction() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::SessionProtos::DataMessage_Reaction* temp = _impl_.reaction_;
  _impl_.reaction_ = 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 ::SessionProtos::DataMessage_Reaction* DataMessage::unsafe_arena_release_reaction() {
  // @@protoc_insertion_point(field_release:SessionProtos.DataMessage.reaction)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::SessionProtos::DataMessage_Reaction* temp = _impl_.reaction_;
  _impl_.reaction_ = nullptr;
  return temp;
}
inline ::SessionProtos::DataMessage_Reaction* DataMessage::_internal_mutable_reaction() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.reaction_ == nullptr) {
    auto* p = CreateMaybeMessage<::SessionProtos::DataMessage_Reaction>(GetArenaForAllocation());
    _impl_.reaction_ = p;
  }
  return _impl_.reaction_;
}
inline ::SessionProtos::DataMessage_Reaction* DataMessage::mutable_reaction() {
  ::SessionProtos::DataMessage_Reaction* _msg = _internal_mutable_reaction();
  // @@protoc_insertion_point(field_mutable:SessionProtos.DataMessage.reaction)
  return _msg;
}
inline void DataMessage::set_allocated_reaction(::SessionProtos::DataMessage_Reaction* reaction) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.reaction_;
  }
  if (reaction) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(reaction);
    if (message_arena != submessage_arena) {
      reaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, reaction, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.reaction_ = reaction;
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.DataMessage.reaction)
}

// optional .SessionProtos.LokiProfile profile = 101;
inline bool DataMessage::_internal_has_profile() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.profile_ != nullptr);
  return value;
}
inline bool DataMessage::has_profile() const {
  return _internal_has_profile();
}
inline void DataMessage::clear_profile() {
  if (_impl_.profile_ != nullptr) _impl_.profile_->Clear();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const ::SessionProtos::LokiProfile& DataMessage::_internal_profile() const {
  const ::SessionProtos::LokiProfile* p = _impl_.profile_;
  return p != nullptr ? *p : reinterpret_cast<const ::SessionProtos::LokiProfile&>(
      ::SessionProtos::_LokiProfile_default_instance_);
}
inline const ::SessionProtos::LokiProfile& DataMessage::profile() const {
  // @@protoc_insertion_point(field_get:SessionProtos.DataMessage.profile)
  return _internal_profile();
}
inline void DataMessage::unsafe_arena_set_allocated_profile(
    ::SessionProtos::LokiProfile* profile) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.profile_);
  }
  _impl_.profile_ = profile;
  if (profile) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:SessionProtos.DataMessage.profile)
}
inline ::SessionProtos::LokiProfile* DataMessage::release_profile() {
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::SessionProtos::LokiProfile* temp = _impl_.profile_;
  _impl_.profile_ = 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 ::SessionProtos::LokiProfile* DataMessage::unsafe_arena_release_profile() {
  // @@protoc_insertion_point(field_release:SessionProtos.DataMessage.profile)
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::SessionProtos::LokiProfile* temp = _impl_.profile_;
  _impl_.profile_ = nullptr;
  return temp;
}
inline ::SessionProtos::LokiProfile* DataMessage::_internal_mutable_profile() {
  _impl_._has_bits_[0] |= 0x00000020u;
  if (_impl_.profile_ == nullptr) {
    auto* p = CreateMaybeMessage<::SessionProtos::LokiProfile>(GetArenaForAllocation());
    _impl_.profile_ = p;
  }
  return _impl_.profile_;
}
inline ::SessionProtos::LokiProfile* DataMessage::mutable_profile() {
  ::SessionProtos::LokiProfile* _msg = _internal_mutable_profile();
  // @@protoc_insertion_point(field_mutable:SessionProtos.DataMessage.profile)
  return _msg;
}
inline void DataMessage::set_allocated_profile(::SessionProtos::LokiProfile* profile) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.profile_;
  }
  if (profile) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(profile);
    if (message_arena != submessage_arena) {
      profile = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, profile, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.profile_ = profile;
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.DataMessage.profile)
}

// optional .SessionProtos.DataMessage.OpenGroupInvitation openGroupInvitation = 102;
inline bool DataMessage::_internal_has_opengroupinvitation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.opengroupinvitation_ != nullptr);
  return value;
}
inline bool DataMessage::has_opengroupinvitation() const {
  return _internal_has_opengroupinvitation();
}
inline void DataMessage::clear_opengroupinvitation() {
  if (_impl_.opengroupinvitation_ != nullptr) _impl_.opengroupinvitation_->Clear();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const ::SessionProtos::DataMessage_OpenGroupInvitation& DataMessage::_internal_opengroupinvitation() const {
  const ::SessionProtos::DataMessage_OpenGroupInvitation* p = _impl_.opengroupinvitation_;
  return p != nullptr ? *p : reinterpret_cast<const ::SessionProtos::DataMessage_OpenGroupInvitation&>(
      ::SessionProtos::_DataMessage_OpenGroupInvitation_default_instance_);
}
inline const ::SessionProtos::DataMessage_OpenGroupInvitation& DataMessage::opengroupinvitation() const {
  // @@protoc_insertion_point(field_get:SessionProtos.DataMessage.openGroupInvitation)
  return _internal_opengroupinvitation();
}
inline void DataMessage::unsafe_arena_set_allocated_opengroupinvitation(
    ::SessionProtos::DataMessage_OpenGroupInvitation* opengroupinvitation) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.opengroupinvitation_);
  }
  _impl_.opengroupinvitation_ = opengroupinvitation;
  if (opengroupinvitation) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:SessionProtos.DataMessage.openGroupInvitation)
}
inline ::SessionProtos::DataMessage_OpenGroupInvitation* DataMessage::release_opengroupinvitation() {
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::SessionProtos::DataMessage_OpenGroupInvitation* temp = _impl_.opengroupinvitation_;
  _impl_.opengroupinvitation_ = 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 ::SessionProtos::DataMessage_OpenGroupInvitation* DataMessage::unsafe_arena_release_opengroupinvitation() {
  // @@protoc_insertion_point(field_release:SessionProtos.DataMessage.openGroupInvitation)
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::SessionProtos::DataMessage_OpenGroupInvitation* temp = _impl_.opengroupinvitation_;
  _impl_.opengroupinvitation_ = nullptr;
  return temp;
}
inline ::SessionProtos::DataMessage_OpenGroupInvitation* DataMessage::_internal_mutable_opengroupinvitation() {
  _impl_._has_bits_[0] |= 0x00000040u;
  if (_impl_.opengroupinvitation_ == nullptr) {
    auto* p = CreateMaybeMessage<::SessionProtos::DataMessage_OpenGroupInvitation>(GetArenaForAllocation());
    _impl_.opengroupinvitation_ = p;
  }
  return _impl_.opengroupinvitation_;
}
inline ::SessionProtos::DataMessage_OpenGroupInvitation* DataMessage::mutable_opengroupinvitation() {
  ::SessionProtos::DataMessage_OpenGroupInvitation* _msg = _internal_mutable_opengroupinvitation();
  // @@protoc_insertion_point(field_mutable:SessionProtos.DataMessage.openGroupInvitation)
  return _msg;
}
inline void DataMessage::set_allocated_opengroupinvitation(::SessionProtos::DataMessage_OpenGroupInvitation* opengroupinvitation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.opengroupinvitation_;
  }
  if (opengroupinvitation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(opengroupinvitation);
    if (message_arena != submessage_arena) {
      opengroupinvitation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, opengroupinvitation, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.opengroupinvitation_ = opengroupinvitation;
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.DataMessage.openGroupInvitation)
}

// optional string syncTarget = 105;
inline bool DataMessage::_internal_has_synctarget() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool DataMessage::has_synctarget() const {
  return _internal_has_synctarget();
}
inline void DataMessage::clear_synctarget() {
  _impl_.synctarget_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& DataMessage::synctarget() const {
  // @@protoc_insertion_point(field_get:SessionProtos.DataMessage.syncTarget)
  return _internal_synctarget();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DataMessage::set_synctarget(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.synctarget_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.DataMessage.syncTarget)
}
inline std::string* DataMessage::mutable_synctarget() {
  std::string* _s = _internal_mutable_synctarget();
  // @@protoc_insertion_point(field_mutable:SessionProtos.DataMessage.syncTarget)
  return _s;
}
inline const std::string& DataMessage::_internal_synctarget() const {
  return _impl_.synctarget_.Get();
}
inline void DataMessage::_internal_set_synctarget(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.synctarget_.Set(value, GetArenaForAllocation());
}
inline std::string* DataMessage::_internal_mutable_synctarget() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.synctarget_.Mutable(GetArenaForAllocation());
}
inline std::string* DataMessage::release_synctarget() {
  // @@protoc_insertion_point(field_release:SessionProtos.DataMessage.syncTarget)
  if (!_internal_has_synctarget()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.synctarget_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.synctarget_.IsDefault()) {
    _impl_.synctarget_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void DataMessage::set_allocated_synctarget(std::string* synctarget) {
  if (synctarget != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.synctarget_.SetAllocated(synctarget, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.synctarget_.IsDefault()) {
    _impl_.synctarget_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.DataMessage.syncTarget)
}

// optional bool blocksCommunityMessageRequests = 106;
inline bool DataMessage::_internal_has_blockscommunitymessagerequests() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool DataMessage::has_blockscommunitymessagerequests() const {
  return _internal_has_blockscommunitymessagerequests();
}
inline void DataMessage::clear_blockscommunitymessagerequests() {
  _impl_.blockscommunitymessagerequests_ = false;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline bool DataMessage::_internal_blockscommunitymessagerequests() const {
  return _impl_.blockscommunitymessagerequests_;
}
inline bool DataMessage::blockscommunitymessagerequests() const {
  // @@protoc_insertion_point(field_get:SessionProtos.DataMessage.blocksCommunityMessageRequests)
  return _internal_blockscommunitymessagerequests();
}
inline void DataMessage::_internal_set_blockscommunitymessagerequests(bool value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.blockscommunitymessagerequests_ = value;
}
inline void DataMessage::set_blockscommunitymessagerequests(bool value) {
  _internal_set_blockscommunitymessagerequests(value);
  // @@protoc_insertion_point(field_set:SessionProtos.DataMessage.blocksCommunityMessageRequests)
}

// optional .SessionProtos.GroupUpdateMessage groupUpdateMessage = 120;
inline bool DataMessage::_internal_has_groupupdatemessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.groupupdatemessage_ != nullptr);
  return value;
}
inline bool DataMessage::has_groupupdatemessage() const {
  return _internal_has_groupupdatemessage();
}
inline void DataMessage::clear_groupupdatemessage() {
  if (_impl_.groupupdatemessage_ != nullptr) _impl_.groupupdatemessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const ::SessionProtos::GroupUpdateMessage& DataMessage::_internal_groupupdatemessage() const {
  const ::SessionProtos::GroupUpdateMessage* p = _impl_.groupupdatemessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::SessionProtos::GroupUpdateMessage&>(
      ::SessionProtos::_GroupUpdateMessage_default_instance_);
}
inline const ::SessionProtos::GroupUpdateMessage& DataMessage::groupupdatemessage() const {
  // @@protoc_insertion_point(field_get:SessionProtos.DataMessage.groupUpdateMessage)
  return _internal_groupupdatemessage();
}
inline void DataMessage::unsafe_arena_set_allocated_groupupdatemessage(
    ::SessionProtos::GroupUpdateMessage* groupupdatemessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.groupupdatemessage_);
  }
  _impl_.groupupdatemessage_ = groupupdatemessage;
  if (groupupdatemessage) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:SessionProtos.DataMessage.groupUpdateMessage)
}
inline ::SessionProtos::GroupUpdateMessage* DataMessage::release_groupupdatemessage() {
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::SessionProtos::GroupUpdateMessage* temp = _impl_.groupupdatemessage_;
  _impl_.groupupdatemessage_ = 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 ::SessionProtos::GroupUpdateMessage* DataMessage::unsafe_arena_release_groupupdatemessage() {
  // @@protoc_insertion_point(field_release:SessionProtos.DataMessage.groupUpdateMessage)
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::SessionProtos::GroupUpdateMessage* temp = _impl_.groupupdatemessage_;
  _impl_.groupupdatemessage_ = nullptr;
  return temp;
}
inline ::SessionProtos::GroupUpdateMessage* DataMessage::_internal_mutable_groupupdatemessage() {
  _impl_._has_bits_[0] |= 0x00000080u;
  if (_impl_.groupupdatemessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::SessionProtos::GroupUpdateMessage>(GetArenaForAllocation());
    _impl_.groupupdatemessage_ = p;
  }
  return _impl_.groupupdatemessage_;
}
inline ::SessionProtos::GroupUpdateMessage* DataMessage::mutable_groupupdatemessage() {
  ::SessionProtos::GroupUpdateMessage* _msg = _internal_mutable_groupupdatemessage();
  // @@protoc_insertion_point(field_mutable:SessionProtos.DataMessage.groupUpdateMessage)
  return _msg;
}
inline void DataMessage::set_allocated_groupupdatemessage(::SessionProtos::GroupUpdateMessage* groupupdatemessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.groupupdatemessage_;
  }
  if (groupupdatemessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(groupupdatemessage);
    if (message_arena != submessage_arena) {
      groupupdatemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, groupupdatemessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.groupupdatemessage_ = groupupdatemessage;
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.DataMessage.groupUpdateMessage)
}

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

// ReceiptMessage

// required .SessionProtos.ReceiptMessage.Type type = 1;
inline bool ReceiptMessage::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ReceiptMessage::has_type() const {
  return _internal_has_type();
}
inline void ReceiptMessage::clear_type() {
  _impl_.type_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline ::SessionProtos::ReceiptMessage_Type ReceiptMessage::_internal_type() const {
  return static_cast< ::SessionProtos::ReceiptMessage_Type >(_impl_.type_);
}
inline ::SessionProtos::ReceiptMessage_Type ReceiptMessage::type() const {
  // @@protoc_insertion_point(field_get:SessionProtos.ReceiptMessage.type)
  return _internal_type();
}
inline void ReceiptMessage::_internal_set_type(::SessionProtos::ReceiptMessage_Type value) {
  assert(::SessionProtos::ReceiptMessage_Type_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.type_ = value;
}
inline void ReceiptMessage::set_type(::SessionProtos::ReceiptMessage_Type value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:SessionProtos.ReceiptMessage.type)
}

// repeated uint64 timestamp = 2;
inline int ReceiptMessage::_internal_timestamp_size() const {
  return _impl_.timestamp_.size();
}
inline int ReceiptMessage::timestamp_size() const {
  return _internal_timestamp_size();
}
inline void ReceiptMessage::clear_timestamp() {
  _impl_.timestamp_.Clear();
}
inline uint64_t ReceiptMessage::_internal_timestamp(int index) const {
  return _impl_.timestamp_.Get(index);
}
inline uint64_t ReceiptMessage::timestamp(int index) const {
  // @@protoc_insertion_point(field_get:SessionProtos.ReceiptMessage.timestamp)
  return _internal_timestamp(index);
}
inline void ReceiptMessage::set_timestamp(int index, uint64_t value) {
  _impl_.timestamp_.Set(index, value);
  // @@protoc_insertion_point(field_set:SessionProtos.ReceiptMessage.timestamp)
}
inline void ReceiptMessage::_internal_add_timestamp(uint64_t value) {
  _impl_.timestamp_.Add(value);
}
inline void ReceiptMessage::add_timestamp(uint64_t value) {
  _internal_add_timestamp(value);
  // @@protoc_insertion_point(field_add:SessionProtos.ReceiptMessage.timestamp)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
ReceiptMessage::_internal_timestamp() const {
  return _impl_.timestamp_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
ReceiptMessage::timestamp() const {
  // @@protoc_insertion_point(field_list:SessionProtos.ReceiptMessage.timestamp)
  return _internal_timestamp();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
ReceiptMessage::_internal_mutable_timestamp() {
  return &_impl_.timestamp_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
ReceiptMessage::mutable_timestamp() {
  // @@protoc_insertion_point(field_mutable_list:SessionProtos.ReceiptMessage.timestamp)
  return _internal_mutable_timestamp();
}

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

// AttachmentPointer

// required fixed64 id = 1;
inline bool AttachmentPointer::_internal_has_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool AttachmentPointer::has_id() const {
  return _internal_has_id();
}
inline void AttachmentPointer::clear_id() {
  _impl_.id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint64_t AttachmentPointer::_internal_id() const {
  return _impl_.id_;
}
inline uint64_t AttachmentPointer::id() const {
  // @@protoc_insertion_point(field_get:SessionProtos.AttachmentPointer.id)
  return _internal_id();
}
inline void AttachmentPointer::_internal_set_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.id_ = value;
}
inline void AttachmentPointer::set_id(uint64_t value) {
  _internal_set_id(value);
  // @@protoc_insertion_point(field_set:SessionProtos.AttachmentPointer.id)
}

// optional string contentType = 2;
inline bool AttachmentPointer::_internal_has_contenttype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool AttachmentPointer::has_contenttype() const {
  return _internal_has_contenttype();
}
inline void AttachmentPointer::clear_contenttype() {
  _impl_.contenttype_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& AttachmentPointer::contenttype() const {
  // @@protoc_insertion_point(field_get:SessionProtos.AttachmentPointer.contentType)
  return _internal_contenttype();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AttachmentPointer::set_contenttype(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.contenttype_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.AttachmentPointer.contentType)
}
inline std::string* AttachmentPointer::mutable_contenttype() {
  std::string* _s = _internal_mutable_contenttype();
  // @@protoc_insertion_point(field_mutable:SessionProtos.AttachmentPointer.contentType)
  return _s;
}
inline const std::string& AttachmentPointer::_internal_contenttype() const {
  return _impl_.contenttype_.Get();
}
inline void AttachmentPointer::_internal_set_contenttype(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.contenttype_.Set(value, GetArenaForAllocation());
}
inline std::string* AttachmentPointer::_internal_mutable_contenttype() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.contenttype_.Mutable(GetArenaForAllocation());
}
inline std::string* AttachmentPointer::release_contenttype() {
  // @@protoc_insertion_point(field_release:SessionProtos.AttachmentPointer.contentType)
  if (!_internal_has_contenttype()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.contenttype_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.contenttype_.IsDefault()) {
    _impl_.contenttype_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void AttachmentPointer::set_allocated_contenttype(std::string* contenttype) {
  if (contenttype != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.contenttype_.SetAllocated(contenttype, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.contenttype_.IsDefault()) {
    _impl_.contenttype_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.AttachmentPointer.contentType)
}

// optional bytes key = 3;
inline bool AttachmentPointer::_internal_has_key() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool AttachmentPointer::has_key() const {
  return _internal_has_key();
}
inline void AttachmentPointer::clear_key() {
  _impl_.key_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& AttachmentPointer::key() const {
  // @@protoc_insertion_point(field_get:SessionProtos.AttachmentPointer.key)
  return _internal_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AttachmentPointer::set_key(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.key_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.AttachmentPointer.key)
}
inline std::string* AttachmentPointer::mutable_key() {
  std::string* _s = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:SessionProtos.AttachmentPointer.key)
  return _s;
}
inline const std::string& AttachmentPointer::_internal_key() const {
  return _impl_.key_.Get();
}
inline void AttachmentPointer::_internal_set_key(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.key_.Set(value, GetArenaForAllocation());
}
inline std::string* AttachmentPointer::_internal_mutable_key() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.key_.Mutable(GetArenaForAllocation());
}
inline std::string* AttachmentPointer::release_key() {
  // @@protoc_insertion_point(field_release:SessionProtos.AttachmentPointer.key)
  if (!_internal_has_key()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.key_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.key_.IsDefault()) {
    _impl_.key_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void AttachmentPointer::set_allocated_key(std::string* key) {
  if (key != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.key_.SetAllocated(key, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.key_.IsDefault()) {
    _impl_.key_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.AttachmentPointer.key)
}

// optional uint32 size = 4;
inline bool AttachmentPointer::_internal_has_size() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool AttachmentPointer::has_size() const {
  return _internal_has_size();
}
inline void AttachmentPointer::clear_size() {
  _impl_.size_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint32_t AttachmentPointer::_internal_size() const {
  return _impl_.size_;
}
inline uint32_t AttachmentPointer::size() const {
  // @@protoc_insertion_point(field_get:SessionProtos.AttachmentPointer.size)
  return _internal_size();
}
inline void AttachmentPointer::_internal_set_size(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.size_ = value;
}
inline void AttachmentPointer::set_size(uint32_t value) {
  _internal_set_size(value);
  // @@protoc_insertion_point(field_set:SessionProtos.AttachmentPointer.size)
}

// optional bytes thumbnail = 5;
inline bool AttachmentPointer::_internal_has_thumbnail() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool AttachmentPointer::has_thumbnail() const {
  return _internal_has_thumbnail();
}
inline void AttachmentPointer::clear_thumbnail() {
  _impl_.thumbnail_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& AttachmentPointer::thumbnail() const {
  // @@protoc_insertion_point(field_get:SessionProtos.AttachmentPointer.thumbnail)
  return _internal_thumbnail();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AttachmentPointer::set_thumbnail(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.thumbnail_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.AttachmentPointer.thumbnail)
}
inline std::string* AttachmentPointer::mutable_thumbnail() {
  std::string* _s = _internal_mutable_thumbnail();
  // @@protoc_insertion_point(field_mutable:SessionProtos.AttachmentPointer.thumbnail)
  return _s;
}
inline const std::string& AttachmentPointer::_internal_thumbnail() const {
  return _impl_.thumbnail_.Get();
}
inline void AttachmentPointer::_internal_set_thumbnail(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.thumbnail_.Set(value, GetArenaForAllocation());
}
inline std::string* AttachmentPointer::_internal_mutable_thumbnail() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.thumbnail_.Mutable(GetArenaForAllocation());
}
inline std::string* AttachmentPointer::release_thumbnail() {
  // @@protoc_insertion_point(field_release:SessionProtos.AttachmentPointer.thumbnail)
  if (!_internal_has_thumbnail()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.thumbnail_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.thumbnail_.IsDefault()) {
    _impl_.thumbnail_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void AttachmentPointer::set_allocated_thumbnail(std::string* thumbnail) {
  if (thumbnail != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.thumbnail_.SetAllocated(thumbnail, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.thumbnail_.IsDefault()) {
    _impl_.thumbnail_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.AttachmentPointer.thumbnail)
}

// optional bytes digest = 6;
inline bool AttachmentPointer::_internal_has_digest() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool AttachmentPointer::has_digest() const {
  return _internal_has_digest();
}
inline void AttachmentPointer::clear_digest() {
  _impl_.digest_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& AttachmentPointer::digest() const {
  // @@protoc_insertion_point(field_get:SessionProtos.AttachmentPointer.digest)
  return _internal_digest();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AttachmentPointer::set_digest(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.digest_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.AttachmentPointer.digest)
}
inline std::string* AttachmentPointer::mutable_digest() {
  std::string* _s = _internal_mutable_digest();
  // @@protoc_insertion_point(field_mutable:SessionProtos.AttachmentPointer.digest)
  return _s;
}
inline const std::string& AttachmentPointer::_internal_digest() const {
  return _impl_.digest_.Get();
}
inline void AttachmentPointer::_internal_set_digest(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.digest_.Set(value, GetArenaForAllocation());
}
inline std::string* AttachmentPointer::_internal_mutable_digest() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.digest_.Mutable(GetArenaForAllocation());
}
inline std::string* AttachmentPointer::release_digest() {
  // @@protoc_insertion_point(field_release:SessionProtos.AttachmentPointer.digest)
  if (!_internal_has_digest()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.digest_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.digest_.IsDefault()) {
    _impl_.digest_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void AttachmentPointer::set_allocated_digest(std::string* digest) {
  if (digest != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.digest_.SetAllocated(digest, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.digest_.IsDefault()) {
    _impl_.digest_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.AttachmentPointer.digest)
}

// optional string fileName = 7;
inline bool AttachmentPointer::_internal_has_filename() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool AttachmentPointer::has_filename() const {
  return _internal_has_filename();
}
inline void AttachmentPointer::clear_filename() {
  _impl_.filename_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& AttachmentPointer::filename() const {
  // @@protoc_insertion_point(field_get:SessionProtos.AttachmentPointer.fileName)
  return _internal_filename();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AttachmentPointer::set_filename(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.filename_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.AttachmentPointer.fileName)
}
inline std::string* AttachmentPointer::mutable_filename() {
  std::string* _s = _internal_mutable_filename();
  // @@protoc_insertion_point(field_mutable:SessionProtos.AttachmentPointer.fileName)
  return _s;
}
inline const std::string& AttachmentPointer::_internal_filename() const {
  return _impl_.filename_.Get();
}
inline void AttachmentPointer::_internal_set_filename(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.filename_.Set(value, GetArenaForAllocation());
}
inline std::string* AttachmentPointer::_internal_mutable_filename() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.filename_.Mutable(GetArenaForAllocation());
}
inline std::string* AttachmentPointer::release_filename() {
  // @@protoc_insertion_point(field_release:SessionProtos.AttachmentPointer.fileName)
  if (!_internal_has_filename()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.filename_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.filename_.IsDefault()) {
    _impl_.filename_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void AttachmentPointer::set_allocated_filename(std::string* filename) {
  if (filename != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.filename_.SetAllocated(filename, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.filename_.IsDefault()) {
    _impl_.filename_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.AttachmentPointer.fileName)
}

// optional uint32 flags = 8;
inline bool AttachmentPointer::_internal_has_flags() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool AttachmentPointer::has_flags() const {
  return _internal_has_flags();
}
inline void AttachmentPointer::clear_flags() {
  _impl_.flags_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint32_t AttachmentPointer::_internal_flags() const {
  return _impl_.flags_;
}
inline uint32_t AttachmentPointer::flags() const {
  // @@protoc_insertion_point(field_get:SessionProtos.AttachmentPointer.flags)
  return _internal_flags();
}
inline void AttachmentPointer::_internal_set_flags(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.flags_ = value;
}
inline void AttachmentPointer::set_flags(uint32_t value) {
  _internal_set_flags(value);
  // @@protoc_insertion_point(field_set:SessionProtos.AttachmentPointer.flags)
}

// optional uint32 width = 9;
inline bool AttachmentPointer::_internal_has_width() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool AttachmentPointer::has_width() const {
  return _internal_has_width();
}
inline void AttachmentPointer::clear_width() {
  _impl_.width_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline uint32_t AttachmentPointer::_internal_width() const {
  return _impl_.width_;
}
inline uint32_t AttachmentPointer::width() const {
  // @@protoc_insertion_point(field_get:SessionProtos.AttachmentPointer.width)
  return _internal_width();
}
inline void AttachmentPointer::_internal_set_width(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.width_ = value;
}
inline void AttachmentPointer::set_width(uint32_t value) {
  _internal_set_width(value);
  // @@protoc_insertion_point(field_set:SessionProtos.AttachmentPointer.width)
}

// optional uint32 height = 10;
inline bool AttachmentPointer::_internal_has_height() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool AttachmentPointer::has_height() const {
  return _internal_has_height();
}
inline void AttachmentPointer::clear_height() {
  _impl_.height_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline uint32_t AttachmentPointer::_internal_height() const {
  return _impl_.height_;
}
inline uint32_t AttachmentPointer::height() const {
  // @@protoc_insertion_point(field_get:SessionProtos.AttachmentPointer.height)
  return _internal_height();
}
inline void AttachmentPointer::_internal_set_height(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.height_ = value;
}
inline void AttachmentPointer::set_height(uint32_t value) {
  _internal_set_height(value);
  // @@protoc_insertion_point(field_set:SessionProtos.AttachmentPointer.height)
}

// optional string caption = 11;
inline bool AttachmentPointer::_internal_has_caption() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool AttachmentPointer::has_caption() const {
  return _internal_has_caption();
}
inline void AttachmentPointer::clear_caption() {
  _impl_.caption_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const std::string& AttachmentPointer::caption() const {
  // @@protoc_insertion_point(field_get:SessionProtos.AttachmentPointer.caption)
  return _internal_caption();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AttachmentPointer::set_caption(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000020u;
 _impl_.caption_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.AttachmentPointer.caption)
}
inline std::string* AttachmentPointer::mutable_caption() {
  std::string* _s = _internal_mutable_caption();
  // @@protoc_insertion_point(field_mutable:SessionProtos.AttachmentPointer.caption)
  return _s;
}
inline const std::string& AttachmentPointer::_internal_caption() const {
  return _impl_.caption_.Get();
}
inline void AttachmentPointer::_internal_set_caption(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.caption_.Set(value, GetArenaForAllocation());
}
inline std::string* AttachmentPointer::_internal_mutable_caption() {
  _impl_._has_bits_[0] |= 0x00000020u;
  return _impl_.caption_.Mutable(GetArenaForAllocation());
}
inline std::string* AttachmentPointer::release_caption() {
  // @@protoc_insertion_point(field_release:SessionProtos.AttachmentPointer.caption)
  if (!_internal_has_caption()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000020u;
  auto* p = _impl_.caption_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.caption_.IsDefault()) {
    _impl_.caption_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void AttachmentPointer::set_allocated_caption(std::string* caption) {
  if (caption != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.caption_.SetAllocated(caption, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.caption_.IsDefault()) {
    _impl_.caption_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.AttachmentPointer.caption)
}

// optional string url = 101;
inline bool AttachmentPointer::_internal_has_url() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool AttachmentPointer::has_url() const {
  return _internal_has_url();
}
inline void AttachmentPointer::clear_url() {
  _impl_.url_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const std::string& AttachmentPointer::url() const {
  // @@protoc_insertion_point(field_get:SessionProtos.AttachmentPointer.url)
  return _internal_url();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AttachmentPointer::set_url(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000040u;
 _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.AttachmentPointer.url)
}
inline std::string* AttachmentPointer::mutable_url() {
  std::string* _s = _internal_mutable_url();
  // @@protoc_insertion_point(field_mutable:SessionProtos.AttachmentPointer.url)
  return _s;
}
inline const std::string& AttachmentPointer::_internal_url() const {
  return _impl_.url_.Get();
}
inline void AttachmentPointer::_internal_set_url(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.url_.Set(value, GetArenaForAllocation());
}
inline std::string* AttachmentPointer::_internal_mutable_url() {
  _impl_._has_bits_[0] |= 0x00000040u;
  return _impl_.url_.Mutable(GetArenaForAllocation());
}
inline std::string* AttachmentPointer::release_url() {
  // @@protoc_insertion_point(field_release:SessionProtos.AttachmentPointer.url)
  if (!_internal_has_url()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000040u;
  auto* p = _impl_.url_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.url_.IsDefault()) {
    _impl_.url_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void AttachmentPointer::set_allocated_url(std::string* url) {
  if (url != nullptr) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.url_.SetAllocated(url, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.url_.IsDefault()) {
    _impl_.url_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.AttachmentPointer.url)
}

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

// SharedConfigMessage

// required .SessionProtos.SharedConfigMessage.Kind kind = 1;
inline bool SharedConfigMessage::_internal_has_kind() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SharedConfigMessage::has_kind() const {
  return _internal_has_kind();
}
inline void SharedConfigMessage::clear_kind() {
  _impl_.kind_ = 1;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::SessionProtos::SharedConfigMessage_Kind SharedConfigMessage::_internal_kind() const {
  return static_cast< ::SessionProtos::SharedConfigMessage_Kind >(_impl_.kind_);
}
inline ::SessionProtos::SharedConfigMessage_Kind SharedConfigMessage::kind() const {
  // @@protoc_insertion_point(field_get:SessionProtos.SharedConfigMessage.kind)
  return _internal_kind();
}
inline void SharedConfigMessage::_internal_set_kind(::SessionProtos::SharedConfigMessage_Kind value) {
  assert(::SessionProtos::SharedConfigMessage_Kind_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.kind_ = value;
}
inline void SharedConfigMessage::set_kind(::SessionProtos::SharedConfigMessage_Kind value) {
  _internal_set_kind(value);
  // @@protoc_insertion_point(field_set:SessionProtos.SharedConfigMessage.kind)
}

// required int64 seqno = 2;
inline bool SharedConfigMessage::_internal_has_seqno() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SharedConfigMessage::has_seqno() const {
  return _internal_has_seqno();
}
inline void SharedConfigMessage::clear_seqno() {
  _impl_.seqno_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int64_t SharedConfigMessage::_internal_seqno() const {
  return _impl_.seqno_;
}
inline int64_t SharedConfigMessage::seqno() const {
  // @@protoc_insertion_point(field_get:SessionProtos.SharedConfigMessage.seqno)
  return _internal_seqno();
}
inline void SharedConfigMessage::_internal_set_seqno(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.seqno_ = value;
}
inline void SharedConfigMessage::set_seqno(int64_t value) {
  _internal_set_seqno(value);
  // @@protoc_insertion_point(field_set:SessionProtos.SharedConfigMessage.seqno)
}

// required bytes data = 3;
inline bool SharedConfigMessage::_internal_has_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SharedConfigMessage::has_data() const {
  return _internal_has_data();
}
inline void SharedConfigMessage::clear_data() {
  _impl_.data_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SharedConfigMessage::data() const {
  // @@protoc_insertion_point(field_get:SessionProtos.SharedConfigMessage.data)
  return _internal_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SharedConfigMessage::set_data(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.SharedConfigMessage.data)
}
inline std::string* SharedConfigMessage::mutable_data() {
  std::string* _s = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:SessionProtos.SharedConfigMessage.data)
  return _s;
}
inline const std::string& SharedConfigMessage::_internal_data() const {
  return _impl_.data_.Get();
}
inline void SharedConfigMessage::_internal_set_data(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.data_.Set(value, GetArenaForAllocation());
}
inline std::string* SharedConfigMessage::_internal_mutable_data() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.data_.Mutable(GetArenaForAllocation());
}
inline std::string* SharedConfigMessage::release_data() {
  // @@protoc_insertion_point(field_release:SessionProtos.SharedConfigMessage.data)
  if (!_internal_has_data()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.data_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SharedConfigMessage::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.data_.SetAllocated(data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.SharedConfigMessage.data)
}

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

// GroupUpdateMessage

// optional .SessionProtos.GroupUpdateInviteMessage inviteMessage = 1;
inline bool GroupUpdateMessage::_internal_has_invitemessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.invitemessage_ != nullptr);
  return value;
}
inline bool GroupUpdateMessage::has_invitemessage() const {
  return _internal_has_invitemessage();
}
inline void GroupUpdateMessage::clear_invitemessage() {
  if (_impl_.invitemessage_ != nullptr) _impl_.invitemessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::SessionProtos::GroupUpdateInviteMessage& GroupUpdateMessage::_internal_invitemessage() const {
  const ::SessionProtos::GroupUpdateInviteMessage* p = _impl_.invitemessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::SessionProtos::GroupUpdateInviteMessage&>(
      ::SessionProtos::_GroupUpdateInviteMessage_default_instance_);
}
inline const ::SessionProtos::GroupUpdateInviteMessage& GroupUpdateMessage::invitemessage() const {
  // @@protoc_insertion_point(field_get:SessionProtos.GroupUpdateMessage.inviteMessage)
  return _internal_invitemessage();
}
inline void GroupUpdateMessage::unsafe_arena_set_allocated_invitemessage(
    ::SessionProtos::GroupUpdateInviteMessage* invitemessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.invitemessage_);
  }
  _impl_.invitemessage_ = invitemessage;
  if (invitemessage) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:SessionProtos.GroupUpdateMessage.inviteMessage)
}
inline ::SessionProtos::GroupUpdateInviteMessage* GroupUpdateMessage::release_invitemessage() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::SessionProtos::GroupUpdateInviteMessage* temp = _impl_.invitemessage_;
  _impl_.invitemessage_ = 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 ::SessionProtos::GroupUpdateInviteMessage* GroupUpdateMessage::unsafe_arena_release_invitemessage() {
  // @@protoc_insertion_point(field_release:SessionProtos.GroupUpdateMessage.inviteMessage)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::SessionProtos::GroupUpdateInviteMessage* temp = _impl_.invitemessage_;
  _impl_.invitemessage_ = nullptr;
  return temp;
}
inline ::SessionProtos::GroupUpdateInviteMessage* GroupUpdateMessage::_internal_mutable_invitemessage() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.invitemessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::SessionProtos::GroupUpdateInviteMessage>(GetArenaForAllocation());
    _impl_.invitemessage_ = p;
  }
  return _impl_.invitemessage_;
}
inline ::SessionProtos::GroupUpdateInviteMessage* GroupUpdateMessage::mutable_invitemessage() {
  ::SessionProtos::GroupUpdateInviteMessage* _msg = _internal_mutable_invitemessage();
  // @@protoc_insertion_point(field_mutable:SessionProtos.GroupUpdateMessage.inviteMessage)
  return _msg;
}
inline void GroupUpdateMessage::set_allocated_invitemessage(::SessionProtos::GroupUpdateInviteMessage* invitemessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.invitemessage_;
  }
  if (invitemessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(invitemessage);
    if (message_arena != submessage_arena) {
      invitemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, invitemessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.invitemessage_ = invitemessage;
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.GroupUpdateMessage.inviteMessage)
}

// optional .SessionProtos.GroupUpdateInfoChangeMessage infoChangeMessage = 2;
inline bool GroupUpdateMessage::_internal_has_infochangemessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.infochangemessage_ != nullptr);
  return value;
}
inline bool GroupUpdateMessage::has_infochangemessage() const {
  return _internal_has_infochangemessage();
}
inline void GroupUpdateMessage::clear_infochangemessage() {
  if (_impl_.infochangemessage_ != nullptr) _impl_.infochangemessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::SessionProtos::GroupUpdateInfoChangeMessage& GroupUpdateMessage::_internal_infochangemessage() const {
  const ::SessionProtos::GroupUpdateInfoChangeMessage* p = _impl_.infochangemessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::SessionProtos::GroupUpdateInfoChangeMessage&>(
      ::SessionProtos::_GroupUpdateInfoChangeMessage_default_instance_);
}
inline const ::SessionProtos::GroupUpdateInfoChangeMessage& GroupUpdateMessage::infochangemessage() const {
  // @@protoc_insertion_point(field_get:SessionProtos.GroupUpdateMessage.infoChangeMessage)
  return _internal_infochangemessage();
}
inline void GroupUpdateMessage::unsafe_arena_set_allocated_infochangemessage(
    ::SessionProtos::GroupUpdateInfoChangeMessage* infochangemessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.infochangemessage_);
  }
  _impl_.infochangemessage_ = infochangemessage;
  if (infochangemessage) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:SessionProtos.GroupUpdateMessage.infoChangeMessage)
}
inline ::SessionProtos::GroupUpdateInfoChangeMessage* GroupUpdateMessage::release_infochangemessage() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::SessionProtos::GroupUpdateInfoChangeMessage* temp = _impl_.infochangemessage_;
  _impl_.infochangemessage_ = 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 ::SessionProtos::GroupUpdateInfoChangeMessage* GroupUpdateMessage::unsafe_arena_release_infochangemessage() {
  // @@protoc_insertion_point(field_release:SessionProtos.GroupUpdateMessage.infoChangeMessage)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::SessionProtos::GroupUpdateInfoChangeMessage* temp = _impl_.infochangemessage_;
  _impl_.infochangemessage_ = nullptr;
  return temp;
}
inline ::SessionProtos::GroupUpdateInfoChangeMessage* GroupUpdateMessage::_internal_mutable_infochangemessage() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.infochangemessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::SessionProtos::GroupUpdateInfoChangeMessage>(GetArenaForAllocation());
    _impl_.infochangemessage_ = p;
  }
  return _impl_.infochangemessage_;
}
inline ::SessionProtos::GroupUpdateInfoChangeMessage* GroupUpdateMessage::mutable_infochangemessage() {
  ::SessionProtos::GroupUpdateInfoChangeMessage* _msg = _internal_mutable_infochangemessage();
  // @@protoc_insertion_point(field_mutable:SessionProtos.GroupUpdateMessage.infoChangeMessage)
  return _msg;
}
inline void GroupUpdateMessage::set_allocated_infochangemessage(::SessionProtos::GroupUpdateInfoChangeMessage* infochangemessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.infochangemessage_;
  }
  if (infochangemessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(infochangemessage);
    if (message_arena != submessage_arena) {
      infochangemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, infochangemessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.infochangemessage_ = infochangemessage;
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.GroupUpdateMessage.infoChangeMessage)
}

// optional .SessionProtos.GroupUpdateMemberChangeMessage memberChangeMessage = 3;
inline bool GroupUpdateMessage::_internal_has_memberchangemessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.memberchangemessage_ != nullptr);
  return value;
}
inline bool GroupUpdateMessage::has_memberchangemessage() const {
  return _internal_has_memberchangemessage();
}
inline void GroupUpdateMessage::clear_memberchangemessage() {
  if (_impl_.memberchangemessage_ != nullptr) _impl_.memberchangemessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::SessionProtos::GroupUpdateMemberChangeMessage& GroupUpdateMessage::_internal_memberchangemessage() const {
  const ::SessionProtos::GroupUpdateMemberChangeMessage* p = _impl_.memberchangemessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::SessionProtos::GroupUpdateMemberChangeMessage&>(
      ::SessionProtos::_GroupUpdateMemberChangeMessage_default_instance_);
}
inline const ::SessionProtos::GroupUpdateMemberChangeMessage& GroupUpdateMessage::memberchangemessage() const {
  // @@protoc_insertion_point(field_get:SessionProtos.GroupUpdateMessage.memberChangeMessage)
  return _internal_memberchangemessage();
}
inline void GroupUpdateMessage::unsafe_arena_set_allocated_memberchangemessage(
    ::SessionProtos::GroupUpdateMemberChangeMessage* memberchangemessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.memberchangemessage_);
  }
  _impl_.memberchangemessage_ = memberchangemessage;
  if (memberchangemessage) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:SessionProtos.GroupUpdateMessage.memberChangeMessage)
}
inline ::SessionProtos::GroupUpdateMemberChangeMessage* GroupUpdateMessage::release_memberchangemessage() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::SessionProtos::GroupUpdateMemberChangeMessage* temp = _impl_.memberchangemessage_;
  _impl_.memberchangemessage_ = 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 ::SessionProtos::GroupUpdateMemberChangeMessage* GroupUpdateMessage::unsafe_arena_release_memberchangemessage() {
  // @@protoc_insertion_point(field_release:SessionProtos.GroupUpdateMessage.memberChangeMessage)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::SessionProtos::GroupUpdateMemberChangeMessage* temp = _impl_.memberchangemessage_;
  _impl_.memberchangemessage_ = nullptr;
  return temp;
}
inline ::SessionProtos::GroupUpdateMemberChangeMessage* GroupUpdateMessage::_internal_mutable_memberchangemessage() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.memberchangemessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::SessionProtos::GroupUpdateMemberChangeMessage>(GetArenaForAllocation());
    _impl_.memberchangemessage_ = p;
  }
  return _impl_.memberchangemessage_;
}
inline ::SessionProtos::GroupUpdateMemberChangeMessage* GroupUpdateMessage::mutable_memberchangemessage() {
  ::SessionProtos::GroupUpdateMemberChangeMessage* _msg = _internal_mutable_memberchangemessage();
  // @@protoc_insertion_point(field_mutable:SessionProtos.GroupUpdateMessage.memberChangeMessage)
  return _msg;
}
inline void GroupUpdateMessage::set_allocated_memberchangemessage(::SessionProtos::GroupUpdateMemberChangeMessage* memberchangemessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.memberchangemessage_;
  }
  if (memberchangemessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(memberchangemessage);
    if (message_arena != submessage_arena) {
      memberchangemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, memberchangemessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.memberchangemessage_ = memberchangemessage;
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.GroupUpdateMessage.memberChangeMessage)
}

// optional .SessionProtos.GroupUpdatePromoteMessage promoteMessage = 4;
inline bool GroupUpdateMessage::_internal_has_promotemessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.promotemessage_ != nullptr);
  return value;
}
inline bool GroupUpdateMessage::has_promotemessage() const {
  return _internal_has_promotemessage();
}
inline void GroupUpdateMessage::clear_promotemessage() {
  if (_impl_.promotemessage_ != nullptr) _impl_.promotemessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::SessionProtos::GroupUpdatePromoteMessage& GroupUpdateMessage::_internal_promotemessage() const {
  const ::SessionProtos::GroupUpdatePromoteMessage* p = _impl_.promotemessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::SessionProtos::GroupUpdatePromoteMessage&>(
      ::SessionProtos::_GroupUpdatePromoteMessage_default_instance_);
}
inline const ::SessionProtos::GroupUpdatePromoteMessage& GroupUpdateMessage::promotemessage() const {
  // @@protoc_insertion_point(field_get:SessionProtos.GroupUpdateMessage.promoteMessage)
  return _internal_promotemessage();
}
inline void GroupUpdateMessage::unsafe_arena_set_allocated_promotemessage(
    ::SessionProtos::GroupUpdatePromoteMessage* promotemessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.promotemessage_);
  }
  _impl_.promotemessage_ = promotemessage;
  if (promotemessage) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:SessionProtos.GroupUpdateMessage.promoteMessage)
}
inline ::SessionProtos::GroupUpdatePromoteMessage* GroupUpdateMessage::release_promotemessage() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::SessionProtos::GroupUpdatePromoteMessage* temp = _impl_.promotemessage_;
  _impl_.promotemessage_ = 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 ::SessionProtos::GroupUpdatePromoteMessage* GroupUpdateMessage::unsafe_arena_release_promotemessage() {
  // @@protoc_insertion_point(field_release:SessionProtos.GroupUpdateMessage.promoteMessage)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::SessionProtos::GroupUpdatePromoteMessage* temp = _impl_.promotemessage_;
  _impl_.promotemessage_ = nullptr;
  return temp;
}
inline ::SessionProtos::GroupUpdatePromoteMessage* GroupUpdateMessage::_internal_mutable_promotemessage() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.promotemessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::SessionProtos::GroupUpdatePromoteMessage>(GetArenaForAllocation());
    _impl_.promotemessage_ = p;
  }
  return _impl_.promotemessage_;
}
inline ::SessionProtos::GroupUpdatePromoteMessage* GroupUpdateMessage::mutable_promotemessage() {
  ::SessionProtos::GroupUpdatePromoteMessage* _msg = _internal_mutable_promotemessage();
  // @@protoc_insertion_point(field_mutable:SessionProtos.GroupUpdateMessage.promoteMessage)
  return _msg;
}
inline void GroupUpdateMessage::set_allocated_promotemessage(::SessionProtos::GroupUpdatePromoteMessage* promotemessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.promotemessage_;
  }
  if (promotemessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(promotemessage);
    if (message_arena != submessage_arena) {
      promotemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, promotemessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.promotemessage_ = promotemessage;
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.GroupUpdateMessage.promoteMessage)
}

// optional .SessionProtos.GroupUpdateMemberLeftMessage memberLeftMessage = 5;
inline bool GroupUpdateMessage::_internal_has_memberleftmessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.memberleftmessage_ != nullptr);
  return value;
}
inline bool GroupUpdateMessage::has_memberleftmessage() const {
  return _internal_has_memberleftmessage();
}
inline void GroupUpdateMessage::clear_memberleftmessage() {
  if (_impl_.memberleftmessage_ != nullptr) _impl_.memberleftmessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const ::SessionProtos::GroupUpdateMemberLeftMessage& GroupUpdateMessage::_internal_memberleftmessage() const {
  const ::SessionProtos::GroupUpdateMemberLeftMessage* p = _impl_.memberleftmessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::SessionProtos::GroupUpdateMemberLeftMessage&>(
      ::SessionProtos::_GroupUpdateMemberLeftMessage_default_instance_);
}
inline const ::SessionProtos::GroupUpdateMemberLeftMessage& GroupUpdateMessage::memberleftmessage() const {
  // @@protoc_insertion_point(field_get:SessionProtos.GroupUpdateMessage.memberLeftMessage)
  return _internal_memberleftmessage();
}
inline void GroupUpdateMessage::unsafe_arena_set_allocated_memberleftmessage(
    ::SessionProtos::GroupUpdateMemberLeftMessage* memberleftmessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.memberleftmessage_);
  }
  _impl_.memberleftmessage_ = memberleftmessage;
  if (memberleftmessage) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:SessionProtos.GroupUpdateMessage.memberLeftMessage)
}
inline ::SessionProtos::GroupUpdateMemberLeftMessage* GroupUpdateMessage::release_memberleftmessage() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::SessionProtos::GroupUpdateMemberLeftMessage* temp = _impl_.memberleftmessage_;
  _impl_.memberleftmessage_ = 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 ::SessionProtos::GroupUpdateMemberLeftMessage* GroupUpdateMessage::unsafe_arena_release_memberleftmessage() {
  // @@protoc_insertion_point(field_release:SessionProtos.GroupUpdateMessage.memberLeftMessage)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::SessionProtos::GroupUpdateMemberLeftMessage* temp = _impl_.memberleftmessage_;
  _impl_.memberleftmessage_ = nullptr;
  return temp;
}
inline ::SessionProtos::GroupUpdateMemberLeftMessage* GroupUpdateMessage::_internal_mutable_memberleftmessage() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.memberleftmessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::SessionProtos::GroupUpdateMemberLeftMessage>(GetArenaForAllocation());
    _impl_.memberleftmessage_ = p;
  }
  return _impl_.memberleftmessage_;
}
inline ::SessionProtos::GroupUpdateMemberLeftMessage* GroupUpdateMessage::mutable_memberleftmessage() {
  ::SessionProtos::GroupUpdateMemberLeftMessage* _msg = _internal_mutable_memberleftmessage();
  // @@protoc_insertion_point(field_mutable:SessionProtos.GroupUpdateMessage.memberLeftMessage)
  return _msg;
}
inline void GroupUpdateMessage::set_allocated_memberleftmessage(::SessionProtos::GroupUpdateMemberLeftMessage* memberleftmessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.memberleftmessage_;
  }
  if (memberleftmessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(memberleftmessage);
    if (message_arena != submessage_arena) {
      memberleftmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, memberleftmessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.memberleftmessage_ = memberleftmessage;
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.GroupUpdateMessage.memberLeftMessage)
}

// optional .SessionProtos.GroupUpdateInviteResponseMessage inviteResponse = 6;
inline bool GroupUpdateMessage::_internal_has_inviteresponse() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.inviteresponse_ != nullptr);
  return value;
}
inline bool GroupUpdateMessage::has_inviteresponse() const {
  return _internal_has_inviteresponse();
}
inline void GroupUpdateMessage::clear_inviteresponse() {
  if (_impl_.inviteresponse_ != nullptr) _impl_.inviteresponse_->Clear();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const ::SessionProtos::GroupUpdateInviteResponseMessage& GroupUpdateMessage::_internal_inviteresponse() const {
  const ::SessionProtos::GroupUpdateInviteResponseMessage* p = _impl_.inviteresponse_;
  return p != nullptr ? *p : reinterpret_cast<const ::SessionProtos::GroupUpdateInviteResponseMessage&>(
      ::SessionProtos::_GroupUpdateInviteResponseMessage_default_instance_);
}
inline const ::SessionProtos::GroupUpdateInviteResponseMessage& GroupUpdateMessage::inviteresponse() const {
  // @@protoc_insertion_point(field_get:SessionProtos.GroupUpdateMessage.inviteResponse)
  return _internal_inviteresponse();
}
inline void GroupUpdateMessage::unsafe_arena_set_allocated_inviteresponse(
    ::SessionProtos::GroupUpdateInviteResponseMessage* inviteresponse) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.inviteresponse_);
  }
  _impl_.inviteresponse_ = inviteresponse;
  if (inviteresponse) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:SessionProtos.GroupUpdateMessage.inviteResponse)
}
inline ::SessionProtos::GroupUpdateInviteResponseMessage* GroupUpdateMessage::release_inviteresponse() {
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::SessionProtos::GroupUpdateInviteResponseMessage* temp = _impl_.inviteresponse_;
  _impl_.inviteresponse_ = 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 ::SessionProtos::GroupUpdateInviteResponseMessage* GroupUpdateMessage::unsafe_arena_release_inviteresponse() {
  // @@protoc_insertion_point(field_release:SessionProtos.GroupUpdateMessage.inviteResponse)
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::SessionProtos::GroupUpdateInviteResponseMessage* temp = _impl_.inviteresponse_;
  _impl_.inviteresponse_ = nullptr;
  return temp;
}
inline ::SessionProtos::GroupUpdateInviteResponseMessage* GroupUpdateMessage::_internal_mutable_inviteresponse() {
  _impl_._has_bits_[0] |= 0x00000020u;
  if (_impl_.inviteresponse_ == nullptr) {
    auto* p = CreateMaybeMessage<::SessionProtos::GroupUpdateInviteResponseMessage>(GetArenaForAllocation());
    _impl_.inviteresponse_ = p;
  }
  return _impl_.inviteresponse_;
}
inline ::SessionProtos::GroupUpdateInviteResponseMessage* GroupUpdateMessage::mutable_inviteresponse() {
  ::SessionProtos::GroupUpdateInviteResponseMessage* _msg = _internal_mutable_inviteresponse();
  // @@protoc_insertion_point(field_mutable:SessionProtos.GroupUpdateMessage.inviteResponse)
  return _msg;
}
inline void GroupUpdateMessage::set_allocated_inviteresponse(::SessionProtos::GroupUpdateInviteResponseMessage* inviteresponse) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.inviteresponse_;
  }
  if (inviteresponse) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(inviteresponse);
    if (message_arena != submessage_arena) {
      inviteresponse = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, inviteresponse, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.inviteresponse_ = inviteresponse;
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.GroupUpdateMessage.inviteResponse)
}

// optional .SessionProtos.GroupUpdateDeleteMemberContentMessage deleteMemberContent = 7;
inline bool GroupUpdateMessage::_internal_has_deletemembercontent() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.deletemembercontent_ != nullptr);
  return value;
}
inline bool GroupUpdateMessage::has_deletemembercontent() const {
  return _internal_has_deletemembercontent();
}
inline void GroupUpdateMessage::clear_deletemembercontent() {
  if (_impl_.deletemembercontent_ != nullptr) _impl_.deletemembercontent_->Clear();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const ::SessionProtos::GroupUpdateDeleteMemberContentMessage& GroupUpdateMessage::_internal_deletemembercontent() const {
  const ::SessionProtos::GroupUpdateDeleteMemberContentMessage* p = _impl_.deletemembercontent_;
  return p != nullptr ? *p : reinterpret_cast<const ::SessionProtos::GroupUpdateDeleteMemberContentMessage&>(
      ::SessionProtos::_GroupUpdateDeleteMemberContentMessage_default_instance_);
}
inline const ::SessionProtos::GroupUpdateDeleteMemberContentMessage& GroupUpdateMessage::deletemembercontent() const {
  // @@protoc_insertion_point(field_get:SessionProtos.GroupUpdateMessage.deleteMemberContent)
  return _internal_deletemembercontent();
}
inline void GroupUpdateMessage::unsafe_arena_set_allocated_deletemembercontent(
    ::SessionProtos::GroupUpdateDeleteMemberContentMessage* deletemembercontent) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.deletemembercontent_);
  }
  _impl_.deletemembercontent_ = deletemembercontent;
  if (deletemembercontent) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:SessionProtos.GroupUpdateMessage.deleteMemberContent)
}
inline ::SessionProtos::GroupUpdateDeleteMemberContentMessage* GroupUpdateMessage::release_deletemembercontent() {
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::SessionProtos::GroupUpdateDeleteMemberContentMessage* temp = _impl_.deletemembercontent_;
  _impl_.deletemembercontent_ = 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 ::SessionProtos::GroupUpdateDeleteMemberContentMessage* GroupUpdateMessage::unsafe_arena_release_deletemembercontent() {
  // @@protoc_insertion_point(field_release:SessionProtos.GroupUpdateMessage.deleteMemberContent)
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::SessionProtos::GroupUpdateDeleteMemberContentMessage* temp = _impl_.deletemembercontent_;
  _impl_.deletemembercontent_ = nullptr;
  return temp;
}
inline ::SessionProtos::GroupUpdateDeleteMemberContentMessage* GroupUpdateMessage::_internal_mutable_deletemembercontent() {
  _impl_._has_bits_[0] |= 0x00000040u;
  if (_impl_.deletemembercontent_ == nullptr) {
    auto* p = CreateMaybeMessage<::SessionProtos::GroupUpdateDeleteMemberContentMessage>(GetArenaForAllocation());
    _impl_.deletemembercontent_ = p;
  }
  return _impl_.deletemembercontent_;
}
inline ::SessionProtos::GroupUpdateDeleteMemberContentMessage* GroupUpdateMessage::mutable_deletemembercontent() {
  ::SessionProtos::GroupUpdateDeleteMemberContentMessage* _msg = _internal_mutable_deletemembercontent();
  // @@protoc_insertion_point(field_mutable:SessionProtos.GroupUpdateMessage.deleteMemberContent)
  return _msg;
}
inline void GroupUpdateMessage::set_allocated_deletemembercontent(::SessionProtos::GroupUpdateDeleteMemberContentMessage* deletemembercontent) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.deletemembercontent_;
  }
  if (deletemembercontent) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(deletemembercontent);
    if (message_arena != submessage_arena) {
      deletemembercontent = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, deletemembercontent, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.deletemembercontent_ = deletemembercontent;
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.GroupUpdateMessage.deleteMemberContent)
}

// optional .SessionProtos.GroupUpdateMemberLeftNotificationMessage memberLeftNotificationMessage = 8;
inline bool GroupUpdateMessage::_internal_has_memberleftnotificationmessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.memberleftnotificationmessage_ != nullptr);
  return value;
}
inline bool GroupUpdateMessage::has_memberleftnotificationmessage() const {
  return _internal_has_memberleftnotificationmessage();
}
inline void GroupUpdateMessage::clear_memberleftnotificationmessage() {
  if (_impl_.memberleftnotificationmessage_ != nullptr) _impl_.memberleftnotificationmessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const ::SessionProtos::GroupUpdateMemberLeftNotificationMessage& GroupUpdateMessage::_internal_memberleftnotificationmessage() const {
  const ::SessionProtos::GroupUpdateMemberLeftNotificationMessage* p = _impl_.memberleftnotificationmessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::SessionProtos::GroupUpdateMemberLeftNotificationMessage&>(
      ::SessionProtos::_GroupUpdateMemberLeftNotificationMessage_default_instance_);
}
inline const ::SessionProtos::GroupUpdateMemberLeftNotificationMessage& GroupUpdateMessage::memberleftnotificationmessage() const {
  // @@protoc_insertion_point(field_get:SessionProtos.GroupUpdateMessage.memberLeftNotificationMessage)
  return _internal_memberleftnotificationmessage();
}
inline void GroupUpdateMessage::unsafe_arena_set_allocated_memberleftnotificationmessage(
    ::SessionProtos::GroupUpdateMemberLeftNotificationMessage* memberleftnotificationmessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.memberleftnotificationmessage_);
  }
  _impl_.memberleftnotificationmessage_ = memberleftnotificationmessage;
  if (memberleftnotificationmessage) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:SessionProtos.GroupUpdateMessage.memberLeftNotificationMessage)
}
inline ::SessionProtos::GroupUpdateMemberLeftNotificationMessage* GroupUpdateMessage::release_memberleftnotificationmessage() {
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::SessionProtos::GroupUpdateMemberLeftNotificationMessage* temp = _impl_.memberleftnotificationmessage_;
  _impl_.memberleftnotificationmessage_ = 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 ::SessionProtos::GroupUpdateMemberLeftNotificationMessage* GroupUpdateMessage::unsafe_arena_release_memberleftnotificationmessage() {
  // @@protoc_insertion_point(field_release:SessionProtos.GroupUpdateMessage.memberLeftNotificationMessage)
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::SessionProtos::GroupUpdateMemberLeftNotificationMessage* temp = _impl_.memberleftnotificationmessage_;
  _impl_.memberleftnotificationmessage_ = nullptr;
  return temp;
}
inline ::SessionProtos::GroupUpdateMemberLeftNotificationMessage* GroupUpdateMessage::_internal_mutable_memberleftnotificationmessage() {
  _impl_._has_bits_[0] |= 0x00000080u;
  if (_impl_.memberleftnotificationmessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::SessionProtos::GroupUpdateMemberLeftNotificationMessage>(GetArenaForAllocation());
    _impl_.memberleftnotificationmessage_ = p;
  }
  return _impl_.memberleftnotificationmessage_;
}
inline ::SessionProtos::GroupUpdateMemberLeftNotificationMessage* GroupUpdateMessage::mutable_memberleftnotificationmessage() {
  ::SessionProtos::GroupUpdateMemberLeftNotificationMessage* _msg = _internal_mutable_memberleftnotificationmessage();
  // @@protoc_insertion_point(field_mutable:SessionProtos.GroupUpdateMessage.memberLeftNotificationMessage)
  return _msg;
}
inline void GroupUpdateMessage::set_allocated_memberleftnotificationmessage(::SessionProtos::GroupUpdateMemberLeftNotificationMessage* memberleftnotificationmessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.memberleftnotificationmessage_;
  }
  if (memberleftnotificationmessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(memberleftnotificationmessage);
    if (message_arena != submessage_arena) {
      memberleftnotificationmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, memberleftnotificationmessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.memberleftnotificationmessage_ = memberleftnotificationmessage;
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.GroupUpdateMessage.memberLeftNotificationMessage)
}

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

// GroupUpdateInviteMessage

// required string groupSessionId = 1;
inline bool GroupUpdateInviteMessage::_internal_has_groupsessionid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool GroupUpdateInviteMessage::has_groupsessionid() const {
  return _internal_has_groupsessionid();
}
inline void GroupUpdateInviteMessage::clear_groupsessionid() {
  _impl_.groupsessionid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& GroupUpdateInviteMessage::groupsessionid() const {
  // @@protoc_insertion_point(field_get:SessionProtos.GroupUpdateInviteMessage.groupSessionId)
  return _internal_groupsessionid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GroupUpdateInviteMessage::set_groupsessionid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.groupsessionid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.GroupUpdateInviteMessage.groupSessionId)
}
inline std::string* GroupUpdateInviteMessage::mutable_groupsessionid() {
  std::string* _s = _internal_mutable_groupsessionid();
  // @@protoc_insertion_point(field_mutable:SessionProtos.GroupUpdateInviteMessage.groupSessionId)
  return _s;
}
inline const std::string& GroupUpdateInviteMessage::_internal_groupsessionid() const {
  return _impl_.groupsessionid_.Get();
}
inline void GroupUpdateInviteMessage::_internal_set_groupsessionid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.groupsessionid_.Set(value, GetArenaForAllocation());
}
inline std::string* GroupUpdateInviteMessage::_internal_mutable_groupsessionid() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.groupsessionid_.Mutable(GetArenaForAllocation());
}
inline std::string* GroupUpdateInviteMessage::release_groupsessionid() {
  // @@protoc_insertion_point(field_release:SessionProtos.GroupUpdateInviteMessage.groupSessionId)
  if (!_internal_has_groupsessionid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.groupsessionid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.groupsessionid_.IsDefault()) {
    _impl_.groupsessionid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void GroupUpdateInviteMessage::set_allocated_groupsessionid(std::string* groupsessionid) {
  if (groupsessionid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.groupsessionid_.SetAllocated(groupsessionid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.groupsessionid_.IsDefault()) {
    _impl_.groupsessionid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.GroupUpdateInviteMessage.groupSessionId)
}

// required string name = 2;
inline bool GroupUpdateInviteMessage::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool GroupUpdateInviteMessage::has_name() const {
  return _internal_has_name();
}
inline void GroupUpdateInviteMessage::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& GroupUpdateInviteMessage::name() const {
  // @@protoc_insertion_point(field_get:SessionProtos.GroupUpdateInviteMessage.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GroupUpdateInviteMessage::set_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.GroupUpdateInviteMessage.name)
}
inline std::string* GroupUpdateInviteMessage::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:SessionProtos.GroupUpdateInviteMessage.name)
  return _s;
}
inline const std::string& GroupUpdateInviteMessage::_internal_name() const {
  return _impl_.name_.Get();
}
inline void GroupUpdateInviteMessage::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* GroupUpdateInviteMessage::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* GroupUpdateInviteMessage::release_name() {
  // @@protoc_insertion_point(field_release:SessionProtos.GroupUpdateInviteMessage.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void GroupUpdateInviteMessage::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.GroupUpdateInviteMessage.name)
}

// required bytes memberAuthData = 3;
inline bool GroupUpdateInviteMessage::_internal_has_memberauthdata() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool GroupUpdateInviteMessage::has_memberauthdata() const {
  return _internal_has_memberauthdata();
}
inline void GroupUpdateInviteMessage::clear_memberauthdata() {
  _impl_.memberauthdata_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& GroupUpdateInviteMessage::memberauthdata() const {
  // @@protoc_insertion_point(field_get:SessionProtos.GroupUpdateInviteMessage.memberAuthData)
  return _internal_memberauthdata();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GroupUpdateInviteMessage::set_memberauthdata(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.memberauthdata_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.GroupUpdateInviteMessage.memberAuthData)
}
inline std::string* GroupUpdateInviteMessage::mutable_memberauthdata() {
  std::string* _s = _internal_mutable_memberauthdata();
  // @@protoc_insertion_point(field_mutable:SessionProtos.GroupUpdateInviteMessage.memberAuthData)
  return _s;
}
inline const std::string& GroupUpdateInviteMessage::_internal_memberauthdata() const {
  return _impl_.memberauthdata_.Get();
}
inline void GroupUpdateInviteMessage::_internal_set_memberauthdata(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.memberauthdata_.Set(value, GetArenaForAllocation());
}
inline std::string* GroupUpdateInviteMessage::_internal_mutable_memberauthdata() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.memberauthdata_.Mutable(GetArenaForAllocation());
}
inline std::string* GroupUpdateInviteMessage::release_memberauthdata() {
  // @@protoc_insertion_point(field_release:SessionProtos.GroupUpdateInviteMessage.memberAuthData)
  if (!_internal_has_memberauthdata()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.memberauthdata_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.memberauthdata_.IsDefault()) {
    _impl_.memberauthdata_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void GroupUpdateInviteMessage::set_allocated_memberauthdata(std::string* memberauthdata) {
  if (memberauthdata != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.memberauthdata_.SetAllocated(memberauthdata, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.memberauthdata_.IsDefault()) {
    _impl_.memberauthdata_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.GroupUpdateInviteMessage.memberAuthData)
}

// required bytes adminSignature = 4;
inline bool GroupUpdateInviteMessage::_internal_has_adminsignature() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool GroupUpdateInviteMessage::has_adminsignature() const {
  return _internal_has_adminsignature();
}
inline void GroupUpdateInviteMessage::clear_adminsignature() {
  _impl_.adminsignature_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& GroupUpdateInviteMessage::adminsignature() const {
  // @@protoc_insertion_point(field_get:SessionProtos.GroupUpdateInviteMessage.adminSignature)
  return _internal_adminsignature();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GroupUpdateInviteMessage::set_adminsignature(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.adminsignature_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.GroupUpdateInviteMessage.adminSignature)
}
inline std::string* GroupUpdateInviteMessage::mutable_adminsignature() {
  std::string* _s = _internal_mutable_adminsignature();
  // @@protoc_insertion_point(field_mutable:SessionProtos.GroupUpdateInviteMessage.adminSignature)
  return _s;
}
inline const std::string& GroupUpdateInviteMessage::_internal_adminsignature() const {
  return _impl_.adminsignature_.Get();
}
inline void GroupUpdateInviteMessage::_internal_set_adminsignature(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.adminsignature_.Set(value, GetArenaForAllocation());
}
inline std::string* GroupUpdateInviteMessage::_internal_mutable_adminsignature() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.adminsignature_.Mutable(GetArenaForAllocation());
}
inline std::string* GroupUpdateInviteMessage::release_adminsignature() {
  // @@protoc_insertion_point(field_release:SessionProtos.GroupUpdateInviteMessage.adminSignature)
  if (!_internal_has_adminsignature()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.adminsignature_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.adminsignature_.IsDefault()) {
    _impl_.adminsignature_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void GroupUpdateInviteMessage::set_allocated_adminsignature(std::string* adminsignature) {
  if (adminsignature != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.adminsignature_.SetAllocated(adminsignature, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.adminsignature_.IsDefault()) {
    _impl_.adminsignature_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.GroupUpdateInviteMessage.adminSignature)
}

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

// GroupUpdatePromoteMessage

// required bytes groupIdentitySeed = 1;
inline bool GroupUpdatePromoteMessage::_internal_has_groupidentityseed() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool GroupUpdatePromoteMessage::has_groupidentityseed() const {
  return _internal_has_groupidentityseed();
}
inline void GroupUpdatePromoteMessage::clear_groupidentityseed() {
  _impl_.groupidentityseed_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& GroupUpdatePromoteMessage::groupidentityseed() const {
  // @@protoc_insertion_point(field_get:SessionProtos.GroupUpdatePromoteMessage.groupIdentitySeed)
  return _internal_groupidentityseed();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GroupUpdatePromoteMessage::set_groupidentityseed(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.groupidentityseed_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.GroupUpdatePromoteMessage.groupIdentitySeed)
}
inline std::string* GroupUpdatePromoteMessage::mutable_groupidentityseed() {
  std::string* _s = _internal_mutable_groupidentityseed();
  // @@protoc_insertion_point(field_mutable:SessionProtos.GroupUpdatePromoteMessage.groupIdentitySeed)
  return _s;
}
inline const std::string& GroupUpdatePromoteMessage::_internal_groupidentityseed() const {
  return _impl_.groupidentityseed_.Get();
}
inline void GroupUpdatePromoteMessage::_internal_set_groupidentityseed(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.groupidentityseed_.Set(value, GetArenaForAllocation());
}
inline std::string* GroupUpdatePromoteMessage::_internal_mutable_groupidentityseed() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.groupidentityseed_.Mutable(GetArenaForAllocation());
}
inline std::string* GroupUpdatePromoteMessage::release_groupidentityseed() {
  // @@protoc_insertion_point(field_release:SessionProtos.GroupUpdatePromoteMessage.groupIdentitySeed)
  if (!_internal_has_groupidentityseed()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.groupidentityseed_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.groupidentityseed_.IsDefault()) {
    _impl_.groupidentityseed_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void GroupUpdatePromoteMessage::set_allocated_groupidentityseed(std::string* groupidentityseed) {
  if (groupidentityseed != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.groupidentityseed_.SetAllocated(groupidentityseed, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.groupidentityseed_.IsDefault()) {
    _impl_.groupidentityseed_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.GroupUpdatePromoteMessage.groupIdentitySeed)
}

// required string name = 2;
inline bool GroupUpdatePromoteMessage::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool GroupUpdatePromoteMessage::has_name() const {
  return _internal_has_name();
}
inline void GroupUpdatePromoteMessage::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& GroupUpdatePromoteMessage::name() const {
  // @@protoc_insertion_point(field_get:SessionProtos.GroupUpdatePromoteMessage.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GroupUpdatePromoteMessage::set_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.GroupUpdatePromoteMessage.name)
}
inline std::string* GroupUpdatePromoteMessage::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:SessionProtos.GroupUpdatePromoteMessage.name)
  return _s;
}
inline const std::string& GroupUpdatePromoteMessage::_internal_name() const {
  return _impl_.name_.Get();
}
inline void GroupUpdatePromoteMessage::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* GroupUpdatePromoteMessage::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* GroupUpdatePromoteMessage::release_name() {
  // @@protoc_insertion_point(field_release:SessionProtos.GroupUpdatePromoteMessage.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void GroupUpdatePromoteMessage::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.GroupUpdatePromoteMessage.name)
}

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

// GroupUpdateInfoChangeMessage

// required .SessionProtos.GroupUpdateInfoChangeMessage.Type type = 1;
inline bool GroupUpdateInfoChangeMessage::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool GroupUpdateInfoChangeMessage::has_type() const {
  return _internal_has_type();
}
inline void GroupUpdateInfoChangeMessage::clear_type() {
  _impl_.type_ = 1;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline ::SessionProtos::GroupUpdateInfoChangeMessage_Type GroupUpdateInfoChangeMessage::_internal_type() const {
  return static_cast< ::SessionProtos::GroupUpdateInfoChangeMessage_Type >(_impl_.type_);
}
inline ::SessionProtos::GroupUpdateInfoChangeMessage_Type GroupUpdateInfoChangeMessage::type() const {
  // @@protoc_insertion_point(field_get:SessionProtos.GroupUpdateInfoChangeMessage.type)
  return _internal_type();
}
inline void GroupUpdateInfoChangeMessage::_internal_set_type(::SessionProtos::GroupUpdateInfoChangeMessage_Type value) {
  assert(::SessionProtos::GroupUpdateInfoChangeMessage_Type_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.type_ = value;
}
inline void GroupUpdateInfoChangeMessage::set_type(::SessionProtos::GroupUpdateInfoChangeMessage_Type value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:SessionProtos.GroupUpdateInfoChangeMessage.type)
}

// optional string updatedName = 2;
inline bool GroupUpdateInfoChangeMessage::_internal_has_updatedname() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool GroupUpdateInfoChangeMessage::has_updatedname() const {
  return _internal_has_updatedname();
}
inline void GroupUpdateInfoChangeMessage::clear_updatedname() {
  _impl_.updatedname_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& GroupUpdateInfoChangeMessage::updatedname() const {
  // @@protoc_insertion_point(field_get:SessionProtos.GroupUpdateInfoChangeMessage.updatedName)
  return _internal_updatedname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GroupUpdateInfoChangeMessage::set_updatedname(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.updatedname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.GroupUpdateInfoChangeMessage.updatedName)
}
inline std::string* GroupUpdateInfoChangeMessage::mutable_updatedname() {
  std::string* _s = _internal_mutable_updatedname();
  // @@protoc_insertion_point(field_mutable:SessionProtos.GroupUpdateInfoChangeMessage.updatedName)
  return _s;
}
inline const std::string& GroupUpdateInfoChangeMessage::_internal_updatedname() const {
  return _impl_.updatedname_.Get();
}
inline void GroupUpdateInfoChangeMessage::_internal_set_updatedname(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.updatedname_.Set(value, GetArenaForAllocation());
}
inline std::string* GroupUpdateInfoChangeMessage::_internal_mutable_updatedname() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.updatedname_.Mutable(GetArenaForAllocation());
}
inline std::string* GroupUpdateInfoChangeMessage::release_updatedname() {
  // @@protoc_insertion_point(field_release:SessionProtos.GroupUpdateInfoChangeMessage.updatedName)
  if (!_internal_has_updatedname()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.updatedname_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.updatedname_.IsDefault()) {
    _impl_.updatedname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void GroupUpdateInfoChangeMessage::set_allocated_updatedname(std::string* updatedname) {
  if (updatedname != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.updatedname_.SetAllocated(updatedname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.updatedname_.IsDefault()) {
    _impl_.updatedname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.GroupUpdateInfoChangeMessage.updatedName)
}

// optional uint32 updatedExpiration = 3;
inline bool GroupUpdateInfoChangeMessage::_internal_has_updatedexpiration() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool GroupUpdateInfoChangeMessage::has_updatedexpiration() const {
  return _internal_has_updatedexpiration();
}
inline void GroupUpdateInfoChangeMessage::clear_updatedexpiration() {
  _impl_.updatedexpiration_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t GroupUpdateInfoChangeMessage::_internal_updatedexpiration() const {
  return _impl_.updatedexpiration_;
}
inline uint32_t GroupUpdateInfoChangeMessage::updatedexpiration() const {
  // @@protoc_insertion_point(field_get:SessionProtos.GroupUpdateInfoChangeMessage.updatedExpiration)
  return _internal_updatedexpiration();
}
inline void GroupUpdateInfoChangeMessage::_internal_set_updatedexpiration(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.updatedexpiration_ = value;
}
inline void GroupUpdateInfoChangeMessage::set_updatedexpiration(uint32_t value) {
  _internal_set_updatedexpiration(value);
  // @@protoc_insertion_point(field_set:SessionProtos.GroupUpdateInfoChangeMessage.updatedExpiration)
}

// required bytes adminSignature = 4;
inline bool GroupUpdateInfoChangeMessage::_internal_has_adminsignature() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool GroupUpdateInfoChangeMessage::has_adminsignature() const {
  return _internal_has_adminsignature();
}
inline void GroupUpdateInfoChangeMessage::clear_adminsignature() {
  _impl_.adminsignature_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& GroupUpdateInfoChangeMessage::adminsignature() const {
  // @@protoc_insertion_point(field_get:SessionProtos.GroupUpdateInfoChangeMessage.adminSignature)
  return _internal_adminsignature();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GroupUpdateInfoChangeMessage::set_adminsignature(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.adminsignature_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.GroupUpdateInfoChangeMessage.adminSignature)
}
inline std::string* GroupUpdateInfoChangeMessage::mutable_adminsignature() {
  std::string* _s = _internal_mutable_adminsignature();
  // @@protoc_insertion_point(field_mutable:SessionProtos.GroupUpdateInfoChangeMessage.adminSignature)
  return _s;
}
inline const std::string& GroupUpdateInfoChangeMessage::_internal_adminsignature() const {
  return _impl_.adminsignature_.Get();
}
inline void GroupUpdateInfoChangeMessage::_internal_set_adminsignature(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.adminsignature_.Set(value, GetArenaForAllocation());
}
inline std::string* GroupUpdateInfoChangeMessage::_internal_mutable_adminsignature() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.adminsignature_.Mutable(GetArenaForAllocation());
}
inline std::string* GroupUpdateInfoChangeMessage::release_adminsignature() {
  // @@protoc_insertion_point(field_release:SessionProtos.GroupUpdateInfoChangeMessage.adminSignature)
  if (!_internal_has_adminsignature()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.adminsignature_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.adminsignature_.IsDefault()) {
    _impl_.adminsignature_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void GroupUpdateInfoChangeMessage::set_allocated_adminsignature(std::string* adminsignature) {
  if (adminsignature != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.adminsignature_.SetAllocated(adminsignature, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.adminsignature_.IsDefault()) {
    _impl_.adminsignature_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.GroupUpdateInfoChangeMessage.adminSignature)
}

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

// GroupUpdateMemberChangeMessage

// required .SessionProtos.GroupUpdateMemberChangeMessage.Type type = 1;
inline bool GroupUpdateMemberChangeMessage::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool GroupUpdateMemberChangeMessage::has_type() const {
  return _internal_has_type();
}
inline void GroupUpdateMemberChangeMessage::clear_type() {
  _impl_.type_ = 1;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::SessionProtos::GroupUpdateMemberChangeMessage_Type GroupUpdateMemberChangeMessage::_internal_type() const {
  return static_cast< ::SessionProtos::GroupUpdateMemberChangeMessage_Type >(_impl_.type_);
}
inline ::SessionProtos::GroupUpdateMemberChangeMessage_Type GroupUpdateMemberChangeMessage::type() const {
  // @@protoc_insertion_point(field_get:SessionProtos.GroupUpdateMemberChangeMessage.type)
  return _internal_type();
}
inline void GroupUpdateMemberChangeMessage::_internal_set_type(::SessionProtos::GroupUpdateMemberChangeMessage_Type value) {
  assert(::SessionProtos::GroupUpdateMemberChangeMessage_Type_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.type_ = value;
}
inline void GroupUpdateMemberChangeMessage::set_type(::SessionProtos::GroupUpdateMemberChangeMessage_Type value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:SessionProtos.GroupUpdateMemberChangeMessage.type)
}

// repeated string memberSessionIds = 2;
inline int GroupUpdateMemberChangeMessage::_internal_membersessionids_size() const {
  return _impl_.membersessionids_.size();
}
inline int GroupUpdateMemberChangeMessage::membersessionids_size() const {
  return _internal_membersessionids_size();
}
inline void GroupUpdateMemberChangeMessage::clear_membersessionids() {
  _impl_.membersessionids_.Clear();
}
inline std::string* GroupUpdateMemberChangeMessage::add_membersessionids() {
  std::string* _s = _internal_add_membersessionids();
  // @@protoc_insertion_point(field_add_mutable:SessionProtos.GroupUpdateMemberChangeMessage.memberSessionIds)
  return _s;
}
inline const std::string& GroupUpdateMemberChangeMessage::_internal_membersessionids(int index) const {
  return _impl_.membersessionids_.Get(index);
}
inline const std::string& GroupUpdateMemberChangeMessage::membersessionids(int index) const {
  // @@protoc_insertion_point(field_get:SessionProtos.GroupUpdateMemberChangeMessage.memberSessionIds)
  return _internal_membersessionids(index);
}
inline std::string* GroupUpdateMemberChangeMessage::mutable_membersessionids(int index) {
  // @@protoc_insertion_point(field_mutable:SessionProtos.GroupUpdateMemberChangeMessage.memberSessionIds)
  return _impl_.membersessionids_.Mutable(index);
}
inline void GroupUpdateMemberChangeMessage::set_membersessionids(int index, const std::string& value) {
  _impl_.membersessionids_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:SessionProtos.GroupUpdateMemberChangeMessage.memberSessionIds)
}
inline void GroupUpdateMemberChangeMessage::set_membersessionids(int index, std::string&& value) {
  _impl_.membersessionids_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:SessionProtos.GroupUpdateMemberChangeMessage.memberSessionIds)
}
inline void GroupUpdateMemberChangeMessage::set_membersessionids(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.membersessionids_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:SessionProtos.GroupUpdateMemberChangeMessage.memberSessionIds)
}
inline void GroupUpdateMemberChangeMessage::set_membersessionids(int index, const char* value, size_t size) {
  _impl_.membersessionids_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:SessionProtos.GroupUpdateMemberChangeMessage.memberSessionIds)
}
inline std::string* GroupUpdateMemberChangeMessage::_internal_add_membersessionids() {
  return _impl_.membersessionids_.Add();
}
inline void GroupUpdateMemberChangeMessage::add_membersessionids(const std::string& value) {
  _impl_.membersessionids_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:SessionProtos.GroupUpdateMemberChangeMessage.memberSessionIds)
}
inline void GroupUpdateMemberChangeMessage::add_membersessionids(std::string&& value) {
  _impl_.membersessionids_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:SessionProtos.GroupUpdateMemberChangeMessage.memberSessionIds)
}
inline void GroupUpdateMemberChangeMessage::add_membersessionids(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.membersessionids_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:SessionProtos.GroupUpdateMemberChangeMessage.memberSessionIds)
}
inline void GroupUpdateMemberChangeMessage::add_membersessionids(const char* value, size_t size) {
  _impl_.membersessionids_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:SessionProtos.GroupUpdateMemberChangeMessage.memberSessionIds)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
GroupUpdateMemberChangeMessage::membersessionids() const {
  // @@protoc_insertion_point(field_list:SessionProtos.GroupUpdateMemberChangeMessage.memberSessionIds)
  return _impl_.membersessionids_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
GroupUpdateMemberChangeMessage::mutable_membersessionids() {
  // @@protoc_insertion_point(field_mutable_list:SessionProtos.GroupUpdateMemberChangeMessage.memberSessionIds)
  return &_impl_.membersessionids_;
}

// optional bool historyShared = 3;
inline bool GroupUpdateMemberChangeMessage::_internal_has_historyshared() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool GroupUpdateMemberChangeMessage::has_historyshared() const {
  return _internal_has_historyshared();
}
inline void GroupUpdateMemberChangeMessage::clear_historyshared() {
  _impl_.historyshared_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool GroupUpdateMemberChangeMessage::_internal_historyshared() const {
  return _impl_.historyshared_;
}
inline bool GroupUpdateMemberChangeMessage::historyshared() const {
  // @@protoc_insertion_point(field_get:SessionProtos.GroupUpdateMemberChangeMessage.historyShared)
  return _internal_historyshared();
}
inline void GroupUpdateMemberChangeMessage::_internal_set_historyshared(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.historyshared_ = value;
}
inline void GroupUpdateMemberChangeMessage::set_historyshared(bool value) {
  _internal_set_historyshared(value);
  // @@protoc_insertion_point(field_set:SessionProtos.GroupUpdateMemberChangeMessage.historyShared)
}

// required bytes adminSignature = 4;
inline bool GroupUpdateMemberChangeMessage::_internal_has_adminsignature() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool GroupUpdateMemberChangeMessage::has_adminsignature() const {
  return _internal_has_adminsignature();
}
inline void GroupUpdateMemberChangeMessage::clear_adminsignature() {
  _impl_.adminsignature_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& GroupUpdateMemberChangeMessage::adminsignature() const {
  // @@protoc_insertion_point(field_get:SessionProtos.GroupUpdateMemberChangeMessage.adminSignature)
  return _internal_adminsignature();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GroupUpdateMemberChangeMessage::set_adminsignature(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.adminsignature_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.GroupUpdateMemberChangeMessage.adminSignature)
}
inline std::string* GroupUpdateMemberChangeMessage::mutable_adminsignature() {
  std::string* _s = _internal_mutable_adminsignature();
  // @@protoc_insertion_point(field_mutable:SessionProtos.GroupUpdateMemberChangeMessage.adminSignature)
  return _s;
}
inline const std::string& GroupUpdateMemberChangeMessage::_internal_adminsignature() const {
  return _impl_.adminsignature_.Get();
}
inline void GroupUpdateMemberChangeMessage::_internal_set_adminsignature(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.adminsignature_.Set(value, GetArenaForAllocation());
}
inline std::string* GroupUpdateMemberChangeMessage::_internal_mutable_adminsignature() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.adminsignature_.Mutable(GetArenaForAllocation());
}
inline std::string* GroupUpdateMemberChangeMessage::release_adminsignature() {
  // @@protoc_insertion_point(field_release:SessionProtos.GroupUpdateMemberChangeMessage.adminSignature)
  if (!_internal_has_adminsignature()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.adminsignature_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.adminsignature_.IsDefault()) {
    _impl_.adminsignature_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void GroupUpdateMemberChangeMessage::set_allocated_adminsignature(std::string* adminsignature) {
  if (adminsignature != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.adminsignature_.SetAllocated(adminsignature, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.adminsignature_.IsDefault()) {
    _impl_.adminsignature_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.GroupUpdateMemberChangeMessage.adminSignature)
}

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

// GroupUpdateMemberLeftMessage

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

// GroupUpdateMemberLeftNotificationMessage

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

// GroupUpdateInviteResponseMessage

// required bool isApproved = 1;
inline bool GroupUpdateInviteResponseMessage::_internal_has_isapproved() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool GroupUpdateInviteResponseMessage::has_isapproved() const {
  return _internal_has_isapproved();
}
inline void GroupUpdateInviteResponseMessage::clear_isapproved() {
  _impl_.isapproved_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool GroupUpdateInviteResponseMessage::_internal_isapproved() const {
  return _impl_.isapproved_;
}
inline bool GroupUpdateInviteResponseMessage::isapproved() const {
  // @@protoc_insertion_point(field_get:SessionProtos.GroupUpdateInviteResponseMessage.isApproved)
  return _internal_isapproved();
}
inline void GroupUpdateInviteResponseMessage::_internal_set_isapproved(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.isapproved_ = value;
}
inline void GroupUpdateInviteResponseMessage::set_isapproved(bool value) {
  _internal_set_isapproved(value);
  // @@protoc_insertion_point(field_set:SessionProtos.GroupUpdateInviteResponseMessage.isApproved)
}

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

// GroupUpdateDeleteMemberContentMessage

// repeated string memberSessionIds = 1;
inline int GroupUpdateDeleteMemberContentMessage::_internal_membersessionids_size() const {
  return _impl_.membersessionids_.size();
}
inline int GroupUpdateDeleteMemberContentMessage::membersessionids_size() const {
  return _internal_membersessionids_size();
}
inline void GroupUpdateDeleteMemberContentMessage::clear_membersessionids() {
  _impl_.membersessionids_.Clear();
}
inline std::string* GroupUpdateDeleteMemberContentMessage::add_membersessionids() {
  std::string* _s = _internal_add_membersessionids();
  // @@protoc_insertion_point(field_add_mutable:SessionProtos.GroupUpdateDeleteMemberContentMessage.memberSessionIds)
  return _s;
}
inline const std::string& GroupUpdateDeleteMemberContentMessage::_internal_membersessionids(int index) const {
  return _impl_.membersessionids_.Get(index);
}
inline const std::string& GroupUpdateDeleteMemberContentMessage::membersessionids(int index) const {
  // @@protoc_insertion_point(field_get:SessionProtos.GroupUpdateDeleteMemberContentMessage.memberSessionIds)
  return _internal_membersessionids(index);
}
inline std::string* GroupUpdateDeleteMemberContentMessage::mutable_membersessionids(int index) {
  // @@protoc_insertion_point(field_mutable:SessionProtos.GroupUpdateDeleteMemberContentMessage.memberSessionIds)
  return _impl_.membersessionids_.Mutable(index);
}
inline void GroupUpdateDeleteMemberContentMessage::set_membersessionids(int index, const std::string& value) {
  _impl_.membersessionids_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:SessionProtos.GroupUpdateDeleteMemberContentMessage.memberSessionIds)
}
inline void GroupUpdateDeleteMemberContentMessage::set_membersessionids(int index, std::string&& value) {
  _impl_.membersessionids_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:SessionProtos.GroupUpdateDeleteMemberContentMessage.memberSessionIds)
}
inline void GroupUpdateDeleteMemberContentMessage::set_membersessionids(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.membersessionids_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:SessionProtos.GroupUpdateDeleteMemberContentMessage.memberSessionIds)
}
inline void GroupUpdateDeleteMemberContentMessage::set_membersessionids(int index, const char* value, size_t size) {
  _impl_.membersessionids_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:SessionProtos.GroupUpdateDeleteMemberContentMessage.memberSessionIds)
}
inline std::string* GroupUpdateDeleteMemberContentMessage::_internal_add_membersessionids() {
  return _impl_.membersessionids_.Add();
}
inline void GroupUpdateDeleteMemberContentMessage::add_membersessionids(const std::string& value) {
  _impl_.membersessionids_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:SessionProtos.GroupUpdateDeleteMemberContentMessage.memberSessionIds)
}
inline void GroupUpdateDeleteMemberContentMessage::add_membersessionids(std::string&& value) {
  _impl_.membersessionids_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:SessionProtos.GroupUpdateDeleteMemberContentMessage.memberSessionIds)
}
inline void GroupUpdateDeleteMemberContentMessage::add_membersessionids(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.membersessionids_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:SessionProtos.GroupUpdateDeleteMemberContentMessage.memberSessionIds)
}
inline void GroupUpdateDeleteMemberContentMessage::add_membersessionids(const char* value, size_t size) {
  _impl_.membersessionids_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:SessionProtos.GroupUpdateDeleteMemberContentMessage.memberSessionIds)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
GroupUpdateDeleteMemberContentMessage::membersessionids() const {
  // @@protoc_insertion_point(field_list:SessionProtos.GroupUpdateDeleteMemberContentMessage.memberSessionIds)
  return _impl_.membersessionids_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
GroupUpdateDeleteMemberContentMessage::mutable_membersessionids() {
  // @@protoc_insertion_point(field_mutable_list:SessionProtos.GroupUpdateDeleteMemberContentMessage.memberSessionIds)
  return &_impl_.membersessionids_;
}

// repeated string messageHashes = 2;
inline int GroupUpdateDeleteMemberContentMessage::_internal_messagehashes_size() const {
  return _impl_.messagehashes_.size();
}
inline int GroupUpdateDeleteMemberContentMessage::messagehashes_size() const {
  return _internal_messagehashes_size();
}
inline void GroupUpdateDeleteMemberContentMessage::clear_messagehashes() {
  _impl_.messagehashes_.Clear();
}
inline std::string* GroupUpdateDeleteMemberContentMessage::add_messagehashes() {
  std::string* _s = _internal_add_messagehashes();
  // @@protoc_insertion_point(field_add_mutable:SessionProtos.GroupUpdateDeleteMemberContentMessage.messageHashes)
  return _s;
}
inline const std::string& GroupUpdateDeleteMemberContentMessage::_internal_messagehashes(int index) const {
  return _impl_.messagehashes_.Get(index);
}
inline const std::string& GroupUpdateDeleteMemberContentMessage::messagehashes(int index) const {
  // @@protoc_insertion_point(field_get:SessionProtos.GroupUpdateDeleteMemberContentMessage.messageHashes)
  return _internal_messagehashes(index);
}
inline std::string* GroupUpdateDeleteMemberContentMessage::mutable_messagehashes(int index) {
  // @@protoc_insertion_point(field_mutable:SessionProtos.GroupUpdateDeleteMemberContentMessage.messageHashes)
  return _impl_.messagehashes_.Mutable(index);
}
inline void GroupUpdateDeleteMemberContentMessage::set_messagehashes(int index, const std::string& value) {
  _impl_.messagehashes_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:SessionProtos.GroupUpdateDeleteMemberContentMessage.messageHashes)
}
inline void GroupUpdateDeleteMemberContentMessage::set_messagehashes(int index, std::string&& value) {
  _impl_.messagehashes_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:SessionProtos.GroupUpdateDeleteMemberContentMessage.messageHashes)
}
inline void GroupUpdateDeleteMemberContentMessage::set_messagehashes(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.messagehashes_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:SessionProtos.GroupUpdateDeleteMemberContentMessage.messageHashes)
}
inline void GroupUpdateDeleteMemberContentMessage::set_messagehashes(int index, const char* value, size_t size) {
  _impl_.messagehashes_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:SessionProtos.GroupUpdateDeleteMemberContentMessage.messageHashes)
}
inline std::string* GroupUpdateDeleteMemberContentMessage::_internal_add_messagehashes() {
  return _impl_.messagehashes_.Add();
}
inline void GroupUpdateDeleteMemberContentMessage::add_messagehashes(const std::string& value) {
  _impl_.messagehashes_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:SessionProtos.GroupUpdateDeleteMemberContentMessage.messageHashes)
}
inline void GroupUpdateDeleteMemberContentMessage::add_messagehashes(std::string&& value) {
  _impl_.messagehashes_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:SessionProtos.GroupUpdateDeleteMemberContentMessage.messageHashes)
}
inline void GroupUpdateDeleteMemberContentMessage::add_messagehashes(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.messagehashes_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:SessionProtos.GroupUpdateDeleteMemberContentMessage.messageHashes)
}
inline void GroupUpdateDeleteMemberContentMessage::add_messagehashes(const char* value, size_t size) {
  _impl_.messagehashes_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:SessionProtos.GroupUpdateDeleteMemberContentMessage.messageHashes)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
GroupUpdateDeleteMemberContentMessage::messagehashes() const {
  // @@protoc_insertion_point(field_list:SessionProtos.GroupUpdateDeleteMemberContentMessage.messageHashes)
  return _impl_.messagehashes_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
GroupUpdateDeleteMemberContentMessage::mutable_messagehashes() {
  // @@protoc_insertion_point(field_mutable_list:SessionProtos.GroupUpdateDeleteMemberContentMessage.messageHashes)
  return &_impl_.messagehashes_;
}

// optional bytes adminSignature = 3;
inline bool GroupUpdateDeleteMemberContentMessage::_internal_has_adminsignature() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool GroupUpdateDeleteMemberContentMessage::has_adminsignature() const {
  return _internal_has_adminsignature();
}
inline void GroupUpdateDeleteMemberContentMessage::clear_adminsignature() {
  _impl_.adminsignature_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& GroupUpdateDeleteMemberContentMessage::adminsignature() const {
  // @@protoc_insertion_point(field_get:SessionProtos.GroupUpdateDeleteMemberContentMessage.adminSignature)
  return _internal_adminsignature();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GroupUpdateDeleteMemberContentMessage::set_adminsignature(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.adminsignature_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.GroupUpdateDeleteMemberContentMessage.adminSignature)
}
inline std::string* GroupUpdateDeleteMemberContentMessage::mutable_adminsignature() {
  std::string* _s = _internal_mutable_adminsignature();
  // @@protoc_insertion_point(field_mutable:SessionProtos.GroupUpdateDeleteMemberContentMessage.adminSignature)
  return _s;
}
inline const std::string& GroupUpdateDeleteMemberContentMessage::_internal_adminsignature() const {
  return _impl_.adminsignature_.Get();
}
inline void GroupUpdateDeleteMemberContentMessage::_internal_set_adminsignature(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.adminsignature_.Set(value, GetArenaForAllocation());
}
inline std::string* GroupUpdateDeleteMemberContentMessage::_internal_mutable_adminsignature() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.adminsignature_.Mutable(GetArenaForAllocation());
}
inline std::string* GroupUpdateDeleteMemberContentMessage::release_adminsignature() {
  // @@protoc_insertion_point(field_release:SessionProtos.GroupUpdateDeleteMemberContentMessage.adminSignature)
  if (!_internal_has_adminsignature()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.adminsignature_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.adminsignature_.IsDefault()) {
    _impl_.adminsignature_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void GroupUpdateDeleteMemberContentMessage::set_allocated_adminsignature(std::string* adminsignature) {
  if (adminsignature != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.adminsignature_.SetAllocated(adminsignature, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.adminsignature_.IsDefault()) {
    _impl_.adminsignature_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.GroupUpdateDeleteMemberContentMessage.adminSignature)
}

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

// ProProof

// optional uint32 version = 1;
inline bool ProProof::_internal_has_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool ProProof::has_version() const {
  return _internal_has_version();
}
inline void ProProof::clear_version() {
  _impl_.version_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t ProProof::_internal_version() const {
  return _impl_.version_;
}
inline uint32_t ProProof::version() const {
  // @@protoc_insertion_point(field_get:SessionProtos.ProProof.version)
  return _internal_version();
}
inline void ProProof::_internal_set_version(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.version_ = value;
}
inline void ProProof::set_version(uint32_t value) {
  _internal_set_version(value);
  // @@protoc_insertion_point(field_set:SessionProtos.ProProof.version)
}

// optional bytes revocationTag = 2;
inline bool ProProof::_internal_has_revocationtag() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ProProof::has_revocationtag() const {
  return _internal_has_revocationtag();
}
inline void ProProof::clear_revocationtag() {
  _impl_.revocationtag_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ProProof::revocationtag() const {
  // @@protoc_insertion_point(field_get:SessionProtos.ProProof.revocationTag)
  return _internal_revocationtag();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ProProof::set_revocationtag(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.revocationtag_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.ProProof.revocationTag)
}
inline std::string* ProProof::mutable_revocationtag() {
  std::string* _s = _internal_mutable_revocationtag();
  // @@protoc_insertion_point(field_mutable:SessionProtos.ProProof.revocationTag)
  return _s;
}
inline const std::string& ProProof::_internal_revocationtag() const {
  return _impl_.revocationtag_.Get();
}
inline void ProProof::_internal_set_revocationtag(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.revocationtag_.Set(value, GetArenaForAllocation());
}
inline std::string* ProProof::_internal_mutable_revocationtag() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.revocationtag_.Mutable(GetArenaForAllocation());
}
inline std::string* ProProof::release_revocationtag() {
  // @@protoc_insertion_point(field_release:SessionProtos.ProProof.revocationTag)
  if (!_internal_has_revocationtag()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.revocationtag_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.revocationtag_.IsDefault()) {
    _impl_.revocationtag_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ProProof::set_allocated_revocationtag(std::string* revocationtag) {
  if (revocationtag != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.revocationtag_.SetAllocated(revocationtag, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.revocationtag_.IsDefault()) {
    _impl_.revocationtag_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.ProProof.revocationTag)
}

// optional bytes rotatingPublicKey = 3;
inline bool ProProof::_internal_has_rotatingpublickey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ProProof::has_rotatingpublickey() const {
  return _internal_has_rotatingpublickey();
}
inline void ProProof::clear_rotatingpublickey() {
  _impl_.rotatingpublickey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& ProProof::rotatingpublickey() const {
  // @@protoc_insertion_point(field_get:SessionProtos.ProProof.rotatingPublicKey)
  return _internal_rotatingpublickey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ProProof::set_rotatingpublickey(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.rotatingpublickey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.ProProof.rotatingPublicKey)
}
inline std::string* ProProof::mutable_rotatingpublickey() {
  std::string* _s = _internal_mutable_rotatingpublickey();
  // @@protoc_insertion_point(field_mutable:SessionProtos.ProProof.rotatingPublicKey)
  return _s;
}
inline const std::string& ProProof::_internal_rotatingpublickey() const {
  return _impl_.rotatingpublickey_.Get();
}
inline void ProProof::_internal_set_rotatingpublickey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.rotatingpublickey_.Set(value, GetArenaForAllocation());
}
inline std::string* ProProof::_internal_mutable_rotatingpublickey() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.rotatingpublickey_.Mutable(GetArenaForAllocation());
}
inline std::string* ProProof::release_rotatingpublickey() {
  // @@protoc_insertion_point(field_release:SessionProtos.ProProof.rotatingPublicKey)
  if (!_internal_has_rotatingpublickey()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.rotatingpublickey_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.rotatingpublickey_.IsDefault()) {
    _impl_.rotatingpublickey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ProProof::set_allocated_rotatingpublickey(std::string* rotatingpublickey) {
  if (rotatingpublickey != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.rotatingpublickey_.SetAllocated(rotatingpublickey, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.rotatingpublickey_.IsDefault()) {
    _impl_.rotatingpublickey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.ProProof.rotatingPublicKey)
}

// optional uint64 expiryUnixTs = 4;
inline bool ProProof::_internal_has_expiryunixts() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool ProProof::has_expiryunixts() const {
  return _internal_has_expiryunixts();
}
inline void ProProof::clear_expiryunixts() {
  _impl_.expiryunixts_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint64_t ProProof::_internal_expiryunixts() const {
  return _impl_.expiryunixts_;
}
inline uint64_t ProProof::expiryunixts() const {
  // @@protoc_insertion_point(field_get:SessionProtos.ProProof.expiryUnixTs)
  return _internal_expiryunixts();
}
inline void ProProof::_internal_set_expiryunixts(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.expiryunixts_ = value;
}
inline void ProProof::set_expiryunixts(uint64_t value) {
  _internal_set_expiryunixts(value);
  // @@protoc_insertion_point(field_set:SessionProtos.ProProof.expiryUnixTs)
}

// optional bytes sig = 5;
inline bool ProProof::_internal_has_sig() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ProProof::has_sig() const {
  return _internal_has_sig();
}
inline void ProProof::clear_sig() {
  _impl_.sig_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& ProProof::sig() const {
  // @@protoc_insertion_point(field_get:SessionProtos.ProProof.sig)
  return _internal_sig();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ProProof::set_sig(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.sig_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SessionProtos.ProProof.sig)
}
inline std::string* ProProof::mutable_sig() {
  std::string* _s = _internal_mutable_sig();
  // @@protoc_insertion_point(field_mutable:SessionProtos.ProProof.sig)
  return _s;
}
inline const std::string& ProProof::_internal_sig() const {
  return _impl_.sig_.Get();
}
inline void ProProof::_internal_set_sig(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.sig_.Set(value, GetArenaForAllocation());
}
inline std::string* ProProof::_internal_mutable_sig() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.sig_.Mutable(GetArenaForAllocation());
}
inline std::string* ProProof::release_sig() {
  // @@protoc_insertion_point(field_release:SessionProtos.ProProof.sig)
  if (!_internal_has_sig()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.sig_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.sig_.IsDefault()) {
    _impl_.sig_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ProProof::set_allocated_sig(std::string* sig) {
  if (sig != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.sig_.SetAllocated(sig, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.sig_.IsDefault()) {
    _impl_.sig_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.ProProof.sig)
}

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

// ProMessage

// optional .SessionProtos.ProProof proof = 1;
inline bool ProMessage::_internal_has_proof() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.proof_ != nullptr);
  return value;
}
inline bool ProMessage::has_proof() const {
  return _internal_has_proof();
}
inline void ProMessage::clear_proof() {
  if (_impl_.proof_ != nullptr) _impl_.proof_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::SessionProtos::ProProof& ProMessage::_internal_proof() const {
  const ::SessionProtos::ProProof* p = _impl_.proof_;
  return p != nullptr ? *p : reinterpret_cast<const ::SessionProtos::ProProof&>(
      ::SessionProtos::_ProProof_default_instance_);
}
inline const ::SessionProtos::ProProof& ProMessage::proof() const {
  // @@protoc_insertion_point(field_get:SessionProtos.ProMessage.proof)
  return _internal_proof();
}
inline void ProMessage::unsafe_arena_set_allocated_proof(
    ::SessionProtos::ProProof* proof) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.proof_);
  }
  _impl_.proof_ = proof;
  if (proof) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:SessionProtos.ProMessage.proof)
}
inline ::SessionProtos::ProProof* ProMessage::release_proof() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::SessionProtos::ProProof* temp = _impl_.proof_;
  _impl_.proof_ = 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 ::SessionProtos::ProProof* ProMessage::unsafe_arena_release_proof() {
  // @@protoc_insertion_point(field_release:SessionProtos.ProMessage.proof)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::SessionProtos::ProProof* temp = _impl_.proof_;
  _impl_.proof_ = nullptr;
  return temp;
}
inline ::SessionProtos::ProProof* ProMessage::_internal_mutable_proof() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.proof_ == nullptr) {
    auto* p = CreateMaybeMessage<::SessionProtos::ProProof>(GetArenaForAllocation());
    _impl_.proof_ = p;
  }
  return _impl_.proof_;
}
inline ::SessionProtos::ProProof* ProMessage::mutable_proof() {
  ::SessionProtos::ProProof* _msg = _internal_mutable_proof();
  // @@protoc_insertion_point(field_mutable:SessionProtos.ProMessage.proof)
  return _msg;
}
inline void ProMessage::set_allocated_proof(::SessionProtos::ProProof* proof) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.proof_;
  }
  if (proof) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(proof);
    if (message_arena != submessage_arena) {
      proof = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, proof, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.proof_ = proof;
  // @@protoc_insertion_point(field_set_allocated:SessionProtos.ProMessage.proof)
}

// optional uint64 profileBitset = 2;
inline bool ProMessage::_internal_has_profilebitset() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ProMessage::has_profilebitset() const {
  return _internal_has_profilebitset();
}
inline void ProMessage::clear_profilebitset() {
  _impl_.profilebitset_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t ProMessage::_internal_profilebitset() const {
  return _impl_.profilebitset_;
}
inline uint64_t ProMessage::profilebitset() const {
  // @@protoc_insertion_point(field_get:SessionProtos.ProMessage.profileBitset)
  return _internal_profilebitset();
}
inline void ProMessage::_internal_set_profilebitset(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.profilebitset_ = value;
}
inline void ProMessage::set_profilebitset(uint64_t value) {
  _internal_set_profilebitset(value);
  // @@protoc_insertion_point(field_set:SessionProtos.ProMessage.profileBitset)
}

// optional uint64 msgBitset = 3;
inline bool ProMessage::_internal_has_msgbitset() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ProMessage::has_msgbitset() const {
  return _internal_has_msgbitset();
}
inline void ProMessage::clear_msgbitset() {
  _impl_.msgbitset_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint64_t ProMessage::_internal_msgbitset() const {
  return _impl_.msgbitset_;
}
inline uint64_t ProMessage::msgbitset() const {
  // @@protoc_insertion_point(field_get:SessionProtos.ProMessage.msgBitset)
  return _internal_msgbitset();
}
inline void ProMessage::_internal_set_msgbitset(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.msgbitset_ = value;
}
inline void ProMessage::set_msgbitset(uint64_t value) {
  _internal_set_msgbitset(value);
  // @@protoc_insertion_point(field_set:SessionProtos.ProMessage.msgBitset)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace SessionProtos

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::SessionProtos::Envelope_Type> : ::std::true_type {};
template <> struct is_proto_enum< ::SessionProtos::TypingMessage_Action> : ::std::true_type {};
template <> struct is_proto_enum< ::SessionProtos::Content_ExpirationType> : ::std::true_type {};
template <> struct is_proto_enum< ::SessionProtos::CallMessage_Type> : ::std::true_type {};
template <> struct is_proto_enum< ::SessionProtos::DataExtractionNotification_Type> : ::std::true_type {};
template <> struct is_proto_enum< ::SessionProtos::DataMessage_Quote_QuotedAttachment_Flags> : ::std::true_type {};
template <> struct is_proto_enum< ::SessionProtos::DataMessage_Reaction_Action> : ::std::true_type {};
template <> struct is_proto_enum< ::SessionProtos::DataMessage_Flags> : ::std::true_type {};
template <> struct is_proto_enum< ::SessionProtos::ReceiptMessage_Type> : ::std::true_type {};
template <> struct is_proto_enum< ::SessionProtos::AttachmentPointer_Flags> : ::std::true_type {};
template <> struct is_proto_enum< ::SessionProtos::SharedConfigMessage_Kind> : ::std::true_type {};
template <> struct is_proto_enum< ::SessionProtos::GroupUpdateInfoChangeMessage_Type> : ::std::true_type {};
template <> struct is_proto_enum< ::SessionProtos::GroupUpdateMemberChangeMessage_Type> : ::std::true_type {};

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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